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.portlet.shopping.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.kernel.annotation.BeanReference;
19  import com.liferay.portal.kernel.cache.CacheRegistry;
20  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
21  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderPath;
23  import com.liferay.portal.kernel.dao.orm.Query;
24  import com.liferay.portal.kernel.dao.orm.QueryPos;
25  import com.liferay.portal.kernel.dao.orm.QueryUtil;
26  import com.liferay.portal.kernel.dao.orm.SQLQuery;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.dao.orm.Type;
29  import com.liferay.portal.kernel.exception.SystemException;
30  import com.liferay.portal.kernel.log.Log;
31  import com.liferay.portal.kernel.log.LogFactoryUtil;
32  import com.liferay.portal.kernel.util.GetterUtil;
33  import com.liferay.portal.kernel.util.InstanceFactory;
34  import com.liferay.portal.kernel.util.OrderByComparator;
35  import com.liferay.portal.kernel.util.StringBundler;
36  import com.liferay.portal.kernel.util.StringPool;
37  import com.liferay.portal.kernel.util.StringUtil;
38  import com.liferay.portal.model.ModelListener;
39  import com.liferay.portal.security.permission.InlineSQLHelperUtil;
40  import com.liferay.portal.service.persistence.BatchSessionUtil;
41  import com.liferay.portal.service.persistence.ResourcePersistence;
42  import com.liferay.portal.service.persistence.UserPersistence;
43  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
44  
45  import com.liferay.portlet.shopping.NoSuchCategoryException;
46  import com.liferay.portlet.shopping.model.ShoppingCategory;
47  import com.liferay.portlet.shopping.model.impl.ShoppingCategoryImpl;
48  import com.liferay.portlet.shopping.model.impl.ShoppingCategoryModelImpl;
49  
50  import java.io.Serializable;
51  
52  import java.util.ArrayList;
53  import java.util.Collections;
54  import java.util.List;
55  
56  /**
57   * <a href="ShoppingCategoryPersistenceImpl.java.html"><b><i>View Source</i></b></a>
58   *
59   * <p>
60   * ServiceBuilder generated this class. Modifications in this class will be
61   * overwritten the next time is generated.
62   * </p>
63   *
64   * @author    Brian Wing Shun Chan
65   * @see       ShoppingCategoryPersistence
66   * @see       ShoppingCategoryUtil
67   * @generated
68   */
69  public class ShoppingCategoryPersistenceImpl extends BasePersistenceImpl<ShoppingCategory>
70      implements ShoppingCategoryPersistence {
71      public static final String FINDER_CLASS_NAME_ENTITY = ShoppingCategoryImpl.class.getName();
72      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
73          ".List";
74      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
75              ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
76              FINDER_CLASS_NAME_LIST, "findByGroupId",
77              new String[] {
78                  Long.class.getName(),
79                  
80              "java.lang.Integer", "java.lang.Integer",
81                  "com.liferay.portal.kernel.util.OrderByComparator"
82              });
83      public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
84              ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
85              FINDER_CLASS_NAME_LIST, "countByGroupId",
86              new String[] { Long.class.getName() });
87      public static final FinderPath FINDER_PATH_FIND_BY_G_P = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
88              ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
89              FINDER_CLASS_NAME_LIST, "findByG_P",
90              new String[] {
91                  Long.class.getName(), Long.class.getName(),
92                  
93              "java.lang.Integer", "java.lang.Integer",
94                  "com.liferay.portal.kernel.util.OrderByComparator"
95              });
96      public static final FinderPath FINDER_PATH_COUNT_BY_G_P = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
97              ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
98              FINDER_CLASS_NAME_LIST, "countByG_P",
99              new String[] { Long.class.getName(), Long.class.getName() });
100     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
101             ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
102             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
103     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
104             ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
105             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
106 
107     public void cacheResult(ShoppingCategory shoppingCategory) {
108         EntityCacheUtil.putResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
109             ShoppingCategoryImpl.class, shoppingCategory.getPrimaryKey(),
110             shoppingCategory);
111     }
112 
113     public void cacheResult(List<ShoppingCategory> shoppingCategories) {
114         for (ShoppingCategory shoppingCategory : shoppingCategories) {
115             if (EntityCacheUtil.getResult(
116                         ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
117                         ShoppingCategoryImpl.class,
118                         shoppingCategory.getPrimaryKey(), this) == null) {
119                 cacheResult(shoppingCategory);
120             }
121         }
122     }
123 
124     public void clearCache() {
125         CacheRegistry.clear(ShoppingCategoryImpl.class.getName());
126         EntityCacheUtil.clearCache(ShoppingCategoryImpl.class.getName());
127         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
128         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
129     }
130 
131     public void clearCache(ShoppingCategory shoppingCategory) {
132         EntityCacheUtil.removeResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
133             ShoppingCategoryImpl.class, shoppingCategory.getPrimaryKey());
134     }
135 
136     public ShoppingCategory create(long categoryId) {
137         ShoppingCategory shoppingCategory = new ShoppingCategoryImpl();
138 
139         shoppingCategory.setNew(true);
140         shoppingCategory.setPrimaryKey(categoryId);
141 
142         return shoppingCategory;
143     }
144 
145     public ShoppingCategory remove(Serializable primaryKey)
146         throws NoSuchModelException, SystemException {
147         return remove(((Long)primaryKey).longValue());
148     }
149 
150     public ShoppingCategory remove(long categoryId)
151         throws NoSuchCategoryException, SystemException {
152         Session session = null;
153 
154         try {
155             session = openSession();
156 
157             ShoppingCategory shoppingCategory = (ShoppingCategory)session.get(ShoppingCategoryImpl.class,
158                     new Long(categoryId));
159 
160             if (shoppingCategory == null) {
161                 if (_log.isWarnEnabled()) {
162                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + categoryId);
163                 }
164 
165                 throw new NoSuchCategoryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
166                     categoryId);
167             }
168 
169             return remove(shoppingCategory);
170         }
171         catch (NoSuchCategoryException nsee) {
172             throw nsee;
173         }
174         catch (Exception e) {
175             throw processException(e);
176         }
177         finally {
178             closeSession(session);
179         }
180     }
181 
182     public ShoppingCategory remove(ShoppingCategory shoppingCategory)
183         throws SystemException {
184         for (ModelListener<ShoppingCategory> listener : listeners) {
185             listener.onBeforeRemove(shoppingCategory);
186         }
187 
188         shoppingCategory = removeImpl(shoppingCategory);
189 
190         for (ModelListener<ShoppingCategory> listener : listeners) {
191             listener.onAfterRemove(shoppingCategory);
192         }
193 
194         return shoppingCategory;
195     }
196 
197     protected ShoppingCategory removeImpl(ShoppingCategory shoppingCategory)
198         throws SystemException {
199         shoppingCategory = toUnwrappedModel(shoppingCategory);
200 
201         Session session = null;
202 
203         try {
204             session = openSession();
205 
206             if (shoppingCategory.isCachedModel() ||
207                     BatchSessionUtil.isEnabled()) {
208                 Object staleObject = session.get(ShoppingCategoryImpl.class,
209                         shoppingCategory.getPrimaryKeyObj());
210 
211                 if (staleObject != null) {
212                     session.evict(staleObject);
213                 }
214             }
215 
216             session.delete(shoppingCategory);
217 
218             session.flush();
219         }
220         catch (Exception e) {
221             throw processException(e);
222         }
223         finally {
224             closeSession(session);
225         }
226 
227         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
228 
229         EntityCacheUtil.removeResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
230             ShoppingCategoryImpl.class, shoppingCategory.getPrimaryKey());
231 
232         return shoppingCategory;
233     }
234 
235     public ShoppingCategory updateImpl(
236         com.liferay.portlet.shopping.model.ShoppingCategory shoppingCategory,
237         boolean merge) throws SystemException {
238         shoppingCategory = toUnwrappedModel(shoppingCategory);
239 
240         Session session = null;
241 
242         try {
243             session = openSession();
244 
245             BatchSessionUtil.update(session, shoppingCategory, merge);
246 
247             shoppingCategory.setNew(false);
248         }
249         catch (Exception e) {
250             throw processException(e);
251         }
252         finally {
253             closeSession(session);
254         }
255 
256         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
257 
258         EntityCacheUtil.putResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
259             ShoppingCategoryImpl.class, shoppingCategory.getPrimaryKey(),
260             shoppingCategory);
261 
262         return shoppingCategory;
263     }
264 
265     protected ShoppingCategory toUnwrappedModel(
266         ShoppingCategory shoppingCategory) {
267         if (shoppingCategory instanceof ShoppingCategoryImpl) {
268             return shoppingCategory;
269         }
270 
271         ShoppingCategoryImpl shoppingCategoryImpl = new ShoppingCategoryImpl();
272 
273         shoppingCategoryImpl.setNew(shoppingCategory.isNew());
274         shoppingCategoryImpl.setPrimaryKey(shoppingCategory.getPrimaryKey());
275 
276         shoppingCategoryImpl.setCategoryId(shoppingCategory.getCategoryId());
277         shoppingCategoryImpl.setGroupId(shoppingCategory.getGroupId());
278         shoppingCategoryImpl.setCompanyId(shoppingCategory.getCompanyId());
279         shoppingCategoryImpl.setUserId(shoppingCategory.getUserId());
280         shoppingCategoryImpl.setUserName(shoppingCategory.getUserName());
281         shoppingCategoryImpl.setCreateDate(shoppingCategory.getCreateDate());
282         shoppingCategoryImpl.setModifiedDate(shoppingCategory.getModifiedDate());
283         shoppingCategoryImpl.setParentCategoryId(shoppingCategory.getParentCategoryId());
284         shoppingCategoryImpl.setName(shoppingCategory.getName());
285         shoppingCategoryImpl.setDescription(shoppingCategory.getDescription());
286 
287         return shoppingCategoryImpl;
288     }
289 
290     public ShoppingCategory findByPrimaryKey(Serializable primaryKey)
291         throws NoSuchModelException, SystemException {
292         return findByPrimaryKey(((Long)primaryKey).longValue());
293     }
294 
295     public ShoppingCategory findByPrimaryKey(long categoryId)
296         throws NoSuchCategoryException, SystemException {
297         ShoppingCategory shoppingCategory = fetchByPrimaryKey(categoryId);
298 
299         if (shoppingCategory == null) {
300             if (_log.isWarnEnabled()) {
301                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + categoryId);
302             }
303 
304             throw new NoSuchCategoryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
305                 categoryId);
306         }
307 
308         return shoppingCategory;
309     }
310 
311     public ShoppingCategory fetchByPrimaryKey(Serializable primaryKey)
312         throws SystemException {
313         return fetchByPrimaryKey(((Long)primaryKey).longValue());
314     }
315 
316     public ShoppingCategory fetchByPrimaryKey(long categoryId)
317         throws SystemException {
318         ShoppingCategory shoppingCategory = (ShoppingCategory)EntityCacheUtil.getResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
319                 ShoppingCategoryImpl.class, categoryId, this);
320 
321         if (shoppingCategory == null) {
322             Session session = null;
323 
324             try {
325                 session = openSession();
326 
327                 shoppingCategory = (ShoppingCategory)session.get(ShoppingCategoryImpl.class,
328                         new Long(categoryId));
329             }
330             catch (Exception e) {
331                 throw processException(e);
332             }
333             finally {
334                 if (shoppingCategory != null) {
335                     cacheResult(shoppingCategory);
336                 }
337 
338                 closeSession(session);
339             }
340         }
341 
342         return shoppingCategory;
343     }
344 
345     public List<ShoppingCategory> findByGroupId(long groupId)
346         throws SystemException {
347         return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
348     }
349 
350     public List<ShoppingCategory> findByGroupId(long groupId, int start, int end)
351         throws SystemException {
352         return findByGroupId(groupId, start, end, null);
353     }
354 
355     public List<ShoppingCategory> findByGroupId(long groupId, int start,
356         int end, OrderByComparator orderByComparator) throws SystemException {
357         Object[] finderArgs = new Object[] {
358                 new Long(groupId),
359                 
360                 String.valueOf(start), String.valueOf(end),
361                 String.valueOf(orderByComparator)
362             };
363 
364         List<ShoppingCategory> list = (List<ShoppingCategory>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
365                 finderArgs, this);
366 
367         if (list == null) {
368             Session session = null;
369 
370             try {
371                 session = openSession();
372 
373                 StringBundler query = null;
374 
375                 if (orderByComparator != null) {
376                     query = new StringBundler(3 +
377                             (orderByComparator.getOrderByFields().length * 3));
378                 }
379                 else {
380                     query = new StringBundler(3);
381                 }
382 
383                 query.append(_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
384 
385                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
386 
387                 if (orderByComparator != null) {
388                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
389                         orderByComparator);
390                 }
391 
392                 else {
393                     query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
394                 }
395 
396                 String sql = query.toString();
397 
398                 Query q = session.createQuery(sql);
399 
400                 QueryPos qPos = QueryPos.getInstance(q);
401 
402                 qPos.add(groupId);
403 
404                 list = (List<ShoppingCategory>)QueryUtil.list(q, getDialect(),
405                         start, end);
406             }
407             catch (Exception e) {
408                 throw processException(e);
409             }
410             finally {
411                 if (list == null) {
412                     list = new ArrayList<ShoppingCategory>();
413                 }
414 
415                 cacheResult(list);
416 
417                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
418                     finderArgs, list);
419 
420                 closeSession(session);
421             }
422         }
423 
424         return list;
425     }
426 
427     public ShoppingCategory findByGroupId_First(long groupId,
428         OrderByComparator orderByComparator)
429         throws NoSuchCategoryException, SystemException {
430         List<ShoppingCategory> list = findByGroupId(groupId, 0, 1,
431                 orderByComparator);
432 
433         if (list.isEmpty()) {
434             StringBundler msg = new StringBundler(4);
435 
436             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
437 
438             msg.append("groupId=");
439             msg.append(groupId);
440 
441             msg.append(StringPool.CLOSE_CURLY_BRACE);
442 
443             throw new NoSuchCategoryException(msg.toString());
444         }
445         else {
446             return list.get(0);
447         }
448     }
449 
450     public ShoppingCategory findByGroupId_Last(long groupId,
451         OrderByComparator orderByComparator)
452         throws NoSuchCategoryException, SystemException {
453         int count = countByGroupId(groupId);
454 
455         List<ShoppingCategory> list = findByGroupId(groupId, count - 1, count,
456                 orderByComparator);
457 
458         if (list.isEmpty()) {
459             StringBundler msg = new StringBundler(4);
460 
461             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
462 
463             msg.append("groupId=");
464             msg.append(groupId);
465 
466             msg.append(StringPool.CLOSE_CURLY_BRACE);
467 
468             throw new NoSuchCategoryException(msg.toString());
469         }
470         else {
471             return list.get(0);
472         }
473     }
474 
475     public ShoppingCategory[] findByGroupId_PrevAndNext(long categoryId,
476         long groupId, OrderByComparator orderByComparator)
477         throws NoSuchCategoryException, SystemException {
478         ShoppingCategory shoppingCategory = findByPrimaryKey(categoryId);
479 
480         Session session = null;
481 
482         try {
483             session = openSession();
484 
485             ShoppingCategory[] array = new ShoppingCategoryImpl[3];
486 
487             array[0] = getByGroupId_PrevAndNext(session, shoppingCategory,
488                     groupId, orderByComparator, true);
489 
490             array[1] = shoppingCategory;
491 
492             array[2] = getByGroupId_PrevAndNext(session, shoppingCategory,
493                     groupId, orderByComparator, false);
494 
495             return array;
496         }
497         catch (Exception e) {
498             throw processException(e);
499         }
500         finally {
501             closeSession(session);
502         }
503     }
504 
505     protected ShoppingCategory getByGroupId_PrevAndNext(Session session,
506         ShoppingCategory shoppingCategory, long groupId,
507         OrderByComparator orderByComparator, boolean previous) {
508         StringBundler query = null;
509 
510         if (orderByComparator != null) {
511             query = new StringBundler(6 +
512                     (orderByComparator.getOrderByFields().length * 6));
513         }
514         else {
515             query = new StringBundler(3);
516         }
517 
518         query.append(_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
519 
520         query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
521 
522         if (orderByComparator != null) {
523             String[] orderByFields = orderByComparator.getOrderByFields();
524 
525             if (orderByFields.length > 0) {
526                 query.append(WHERE_AND);
527             }
528 
529             for (int i = 0; i < orderByFields.length; i++) {
530                 query.append(_ORDER_BY_ENTITY_ALIAS);
531                 query.append(orderByFields[i]);
532 
533                 if ((i + 1) < orderByFields.length) {
534                     if (orderByComparator.isAscending() ^ previous) {
535                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
536                     }
537                     else {
538                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
539                     }
540                 }
541                 else {
542                     if (orderByComparator.isAscending() ^ previous) {
543                         query.append(WHERE_GREATER_THAN);
544                     }
545                     else {
546                         query.append(WHERE_LESSER_THAN);
547                     }
548                 }
549             }
550 
551             query.append(ORDER_BY_CLAUSE);
552 
553             for (int i = 0; i < orderByFields.length; i++) {
554                 query.append(_ORDER_BY_ENTITY_ALIAS);
555                 query.append(orderByFields[i]);
556 
557                 if ((i + 1) < orderByFields.length) {
558                     if (orderByComparator.isAscending() ^ previous) {
559                         query.append(ORDER_BY_ASC_HAS_NEXT);
560                     }
561                     else {
562                         query.append(ORDER_BY_DESC_HAS_NEXT);
563                     }
564                 }
565                 else {
566                     if (orderByComparator.isAscending() ^ previous) {
567                         query.append(ORDER_BY_ASC);
568                     }
569                     else {
570                         query.append(ORDER_BY_DESC);
571                     }
572                 }
573             }
574         }
575 
576         else {
577             query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
578         }
579 
580         String sql = query.toString();
581 
582         Query q = session.createQuery(sql);
583 
584         q.setFirstResult(0);
585         q.setMaxResults(2);
586 
587         QueryPos qPos = QueryPos.getInstance(q);
588 
589         qPos.add(groupId);
590 
591         if (orderByComparator != null) {
592             Object[] values = orderByComparator.getOrderByValues(shoppingCategory);
593 
594             for (Object value : values) {
595                 qPos.add(value);
596             }
597         }
598 
599         List<ShoppingCategory> list = q.list();
600 
601         if (list.size() == 2) {
602             return list.get(1);
603         }
604         else {
605             return null;
606         }
607     }
608 
609     public List<ShoppingCategory> filterFindByGroupId(long groupId)
610         throws SystemException {
611         return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
612             QueryUtil.ALL_POS, null);
613     }
614 
615     public List<ShoppingCategory> filterFindByGroupId(long groupId, int start,
616         int end) throws SystemException {
617         return filterFindByGroupId(groupId, start, end, null);
618     }
619 
620     public List<ShoppingCategory> filterFindByGroupId(long groupId, int start,
621         int end, OrderByComparator orderByComparator) throws SystemException {
622         if (!InlineSQLHelperUtil.isEnabled(groupId)) {
623             return findByGroupId(groupId, start, end, orderByComparator);
624         }
625 
626         Session session = null;
627 
628         try {
629             session = openSession();
630 
631             StringBundler query = null;
632 
633             if (orderByComparator != null) {
634                 query = new StringBundler(3 +
635                         (orderByComparator.getOrderByFields().length * 3));
636             }
637             else {
638                 query = new StringBundler(3);
639             }
640 
641             query.append(_FILTER_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
642 
643             query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
644 
645             if (orderByComparator != null) {
646                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
647                     orderByComparator);
648             }
649 
650             else {
651                 query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
652             }
653 
654             String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
655                     ShoppingCategory.class.getName(),
656                     _FILTER_COLUMN_CATEGORYID, _FILTER_COLUMN_USERID, groupId);
657 
658             SQLQuery q = session.createSQLQuery(sql);
659 
660             q.addEntity(_FILTER_ENTITY_ALIAS, ShoppingCategoryImpl.class);
661 
662             QueryPos qPos = QueryPos.getInstance(q);
663 
664             qPos.add(groupId);
665 
666             return (List<ShoppingCategory>)QueryUtil.list(q, getDialect(),
667                 start, end);
668         }
669         catch (Exception e) {
670             throw processException(e);
671         }
672         finally {
673             closeSession(session);
674         }
675     }
676 
677     public List<ShoppingCategory> findByG_P(long groupId, long parentCategoryId)
678         throws SystemException {
679         return findByG_P(groupId, parentCategoryId, QueryUtil.ALL_POS,
680             QueryUtil.ALL_POS, null);
681     }
682 
683     public List<ShoppingCategory> findByG_P(long groupId,
684         long parentCategoryId, int start, int end) throws SystemException {
685         return findByG_P(groupId, parentCategoryId, start, end, null);
686     }
687 
688     public List<ShoppingCategory> findByG_P(long groupId,
689         long parentCategoryId, int start, int end,
690         OrderByComparator orderByComparator) throws SystemException {
691         Object[] finderArgs = new Object[] {
692                 new Long(groupId), new Long(parentCategoryId),
693                 
694                 String.valueOf(start), String.valueOf(end),
695                 String.valueOf(orderByComparator)
696             };
697 
698         List<ShoppingCategory> list = (List<ShoppingCategory>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P,
699                 finderArgs, this);
700 
701         if (list == null) {
702             Session session = null;
703 
704             try {
705                 session = openSession();
706 
707                 StringBundler query = null;
708 
709                 if (orderByComparator != null) {
710                     query = new StringBundler(4 +
711                             (orderByComparator.getOrderByFields().length * 3));
712                 }
713                 else {
714                     query = new StringBundler(4);
715                 }
716 
717                 query.append(_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
718 
719                 query.append(_FINDER_COLUMN_G_P_GROUPID_2);
720 
721                 query.append(_FINDER_COLUMN_G_P_PARENTCATEGORYID_2);
722 
723                 if (orderByComparator != null) {
724                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
725                         orderByComparator);
726                 }
727 
728                 else {
729                     query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
730                 }
731 
732                 String sql = query.toString();
733 
734                 Query q = session.createQuery(sql);
735 
736                 QueryPos qPos = QueryPos.getInstance(q);
737 
738                 qPos.add(groupId);
739 
740                 qPos.add(parentCategoryId);
741 
742                 list = (List<ShoppingCategory>)QueryUtil.list(q, getDialect(),
743                         start, end);
744             }
745             catch (Exception e) {
746                 throw processException(e);
747             }
748             finally {
749                 if (list == null) {
750                     list = new ArrayList<ShoppingCategory>();
751                 }
752 
753                 cacheResult(list);
754 
755                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P, finderArgs,
756                     list);
757 
758                 closeSession(session);
759             }
760         }
761 
762         return list;
763     }
764 
765     public ShoppingCategory findByG_P_First(long groupId,
766         long parentCategoryId, OrderByComparator orderByComparator)
767         throws NoSuchCategoryException, SystemException {
768         List<ShoppingCategory> list = findByG_P(groupId, parentCategoryId, 0,
769                 1, orderByComparator);
770 
771         if (list.isEmpty()) {
772             StringBundler msg = new StringBundler(6);
773 
774             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
775 
776             msg.append("groupId=");
777             msg.append(groupId);
778 
779             msg.append(", parentCategoryId=");
780             msg.append(parentCategoryId);
781 
782             msg.append(StringPool.CLOSE_CURLY_BRACE);
783 
784             throw new NoSuchCategoryException(msg.toString());
785         }
786         else {
787             return list.get(0);
788         }
789     }
790 
791     public ShoppingCategory findByG_P_Last(long groupId, long parentCategoryId,
792         OrderByComparator orderByComparator)
793         throws NoSuchCategoryException, SystemException {
794         int count = countByG_P(groupId, parentCategoryId);
795 
796         List<ShoppingCategory> list = findByG_P(groupId, parentCategoryId,
797                 count - 1, count, orderByComparator);
798 
799         if (list.isEmpty()) {
800             StringBundler msg = new StringBundler(6);
801 
802             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
803 
804             msg.append("groupId=");
805             msg.append(groupId);
806 
807             msg.append(", parentCategoryId=");
808             msg.append(parentCategoryId);
809 
810             msg.append(StringPool.CLOSE_CURLY_BRACE);
811 
812             throw new NoSuchCategoryException(msg.toString());
813         }
814         else {
815             return list.get(0);
816         }
817     }
818 
819     public ShoppingCategory[] findByG_P_PrevAndNext(long categoryId,
820         long groupId, long parentCategoryId, OrderByComparator orderByComparator)
821         throws NoSuchCategoryException, SystemException {
822         ShoppingCategory shoppingCategory = findByPrimaryKey(categoryId);
823 
824         Session session = null;
825 
826         try {
827             session = openSession();
828 
829             ShoppingCategory[] array = new ShoppingCategoryImpl[3];
830 
831             array[0] = getByG_P_PrevAndNext(session, shoppingCategory, groupId,
832                     parentCategoryId, orderByComparator, true);
833 
834             array[1] = shoppingCategory;
835 
836             array[2] = getByG_P_PrevAndNext(session, shoppingCategory, groupId,
837                     parentCategoryId, orderByComparator, false);
838 
839             return array;
840         }
841         catch (Exception e) {
842             throw processException(e);
843         }
844         finally {
845             closeSession(session);
846         }
847     }
848 
849     protected ShoppingCategory getByG_P_PrevAndNext(Session session,
850         ShoppingCategory shoppingCategory, long groupId, long parentCategoryId,
851         OrderByComparator orderByComparator, boolean previous) {
852         StringBundler query = null;
853 
854         if (orderByComparator != null) {
855             query = new StringBundler(6 +
856                     (orderByComparator.getOrderByFields().length * 6));
857         }
858         else {
859             query = new StringBundler(3);
860         }
861 
862         query.append(_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
863 
864         query.append(_FINDER_COLUMN_G_P_GROUPID_2);
865 
866         query.append(_FINDER_COLUMN_G_P_PARENTCATEGORYID_2);
867 
868         if (orderByComparator != null) {
869             String[] orderByFields = orderByComparator.getOrderByFields();
870 
871             if (orderByFields.length > 0) {
872                 query.append(WHERE_AND);
873             }
874 
875             for (int i = 0; i < orderByFields.length; i++) {
876                 query.append(_ORDER_BY_ENTITY_ALIAS);
877                 query.append(orderByFields[i]);
878 
879                 if ((i + 1) < orderByFields.length) {
880                     if (orderByComparator.isAscending() ^ previous) {
881                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
882                     }
883                     else {
884                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
885                     }
886                 }
887                 else {
888                     if (orderByComparator.isAscending() ^ previous) {
889                         query.append(WHERE_GREATER_THAN);
890                     }
891                     else {
892                         query.append(WHERE_LESSER_THAN);
893                     }
894                 }
895             }
896 
897             query.append(ORDER_BY_CLAUSE);
898 
899             for (int i = 0; i < orderByFields.length; i++) {
900                 query.append(_ORDER_BY_ENTITY_ALIAS);
901                 query.append(orderByFields[i]);
902 
903                 if ((i + 1) < orderByFields.length) {
904                     if (orderByComparator.isAscending() ^ previous) {
905                         query.append(ORDER_BY_ASC_HAS_NEXT);
906                     }
907                     else {
908                         query.append(ORDER_BY_DESC_HAS_NEXT);
909                     }
910                 }
911                 else {
912                     if (orderByComparator.isAscending() ^ previous) {
913                         query.append(ORDER_BY_ASC);
914                     }
915                     else {
916                         query.append(ORDER_BY_DESC);
917                     }
918                 }
919             }
920         }
921 
922         else {
923             query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
924         }
925 
926         String sql = query.toString();
927 
928         Query q = session.createQuery(sql);
929 
930         q.setFirstResult(0);
931         q.setMaxResults(2);
932 
933         QueryPos qPos = QueryPos.getInstance(q);
934 
935         qPos.add(groupId);
936 
937         qPos.add(parentCategoryId);
938 
939         if (orderByComparator != null) {
940             Object[] values = orderByComparator.getOrderByValues(shoppingCategory);
941 
942             for (Object value : values) {
943                 qPos.add(value);
944             }
945         }
946 
947         List<ShoppingCategory> list = q.list();
948 
949         if (list.size() == 2) {
950             return list.get(1);
951         }
952         else {
953             return null;
954         }
955     }
956 
957     public List<ShoppingCategory> filterFindByG_P(long groupId,
958         long parentCategoryId) throws SystemException {
959         return filterFindByG_P(groupId, parentCategoryId, QueryUtil.ALL_POS,
960             QueryUtil.ALL_POS, null);
961     }
962 
963     public List<ShoppingCategory> filterFindByG_P(long groupId,
964         long parentCategoryId, int start, int end) throws SystemException {
965         return filterFindByG_P(groupId, parentCategoryId, start, end, null);
966     }
967 
968     public List<ShoppingCategory> filterFindByG_P(long groupId,
969         long parentCategoryId, int start, int end,
970         OrderByComparator orderByComparator) throws SystemException {
971         if (!InlineSQLHelperUtil.isEnabled(groupId)) {
972             return findByG_P(groupId, parentCategoryId, start, end,
973                 orderByComparator);
974         }
975 
976         Session session = null;
977 
978         try {
979             session = openSession();
980 
981             StringBundler query = null;
982 
983             if (orderByComparator != null) {
984                 query = new StringBundler(4 +
985                         (orderByComparator.getOrderByFields().length * 3));
986             }
987             else {
988                 query = new StringBundler(4);
989             }
990 
991             query.append(_FILTER_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
992 
993             query.append(_FINDER_COLUMN_G_P_GROUPID_2);
994 
995             query.append(_FINDER_COLUMN_G_P_PARENTCATEGORYID_2);
996 
997             if (orderByComparator != null) {
998                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
999                     orderByComparator);
1000            }
1001
1002            else {
1003                query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
1004            }
1005
1006            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1007                    ShoppingCategory.class.getName(),
1008                    _FILTER_COLUMN_CATEGORYID, _FILTER_COLUMN_USERID, groupId);
1009
1010            SQLQuery q = session.createSQLQuery(sql);
1011
1012            q.addEntity(_FILTER_ENTITY_ALIAS, ShoppingCategoryImpl.class);
1013
1014            QueryPos qPos = QueryPos.getInstance(q);
1015
1016            qPos.add(groupId);
1017
1018            qPos.add(parentCategoryId);
1019
1020            return (List<ShoppingCategory>)QueryUtil.list(q, getDialect(),
1021                start, end);
1022        }
1023        catch (Exception e) {
1024            throw processException(e);
1025        }
1026        finally {
1027            closeSession(session);
1028        }
1029    }
1030
1031    public List<ShoppingCategory> findAll() throws SystemException {
1032        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1033    }
1034
1035    public List<ShoppingCategory> findAll(int start, int end)
1036        throws SystemException {
1037        return findAll(start, end, null);
1038    }
1039
1040    public List<ShoppingCategory> findAll(int start, int end,
1041        OrderByComparator orderByComparator) throws SystemException {
1042        Object[] finderArgs = new Object[] {
1043                String.valueOf(start), String.valueOf(end),
1044                String.valueOf(orderByComparator)
1045            };
1046
1047        List<ShoppingCategory> list = (List<ShoppingCategory>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1048                finderArgs, this);
1049
1050        if (list == null) {
1051            Session session = null;
1052
1053            try {
1054                session = openSession();
1055
1056                StringBundler query = null;
1057                String sql = null;
1058
1059                if (orderByComparator != null) {
1060                    query = new StringBundler(2 +
1061                            (orderByComparator.getOrderByFields().length * 3));
1062
1063                    query.append(_SQL_SELECT_SHOPPINGCATEGORY);
1064
1065                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1066                        orderByComparator);
1067
1068                    sql = query.toString();
1069                }
1070
1071                else {
1072                    sql = _SQL_SELECT_SHOPPINGCATEGORY.concat(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
1073                }
1074
1075                Query q = session.createQuery(sql);
1076
1077                if (orderByComparator == null) {
1078                    list = (List<ShoppingCategory>)QueryUtil.list(q,
1079                            getDialect(), start, end, false);
1080
1081                    Collections.sort(list);
1082                }
1083                else {
1084                    list = (List<ShoppingCategory>)QueryUtil.list(q,
1085                            getDialect(), start, end);
1086                }
1087            }
1088            catch (Exception e) {
1089                throw processException(e);
1090            }
1091            finally {
1092                if (list == null) {
1093                    list = new ArrayList<ShoppingCategory>();
1094                }
1095
1096                cacheResult(list);
1097
1098                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1099
1100                closeSession(session);
1101            }
1102        }
1103
1104        return list;
1105    }
1106
1107    public void removeByGroupId(long groupId) throws SystemException {
1108        for (ShoppingCategory shoppingCategory : findByGroupId(groupId)) {
1109            remove(shoppingCategory);
1110        }
1111    }
1112
1113    public void removeByG_P(long groupId, long parentCategoryId)
1114        throws SystemException {
1115        for (ShoppingCategory shoppingCategory : findByG_P(groupId,
1116                parentCategoryId)) {
1117            remove(shoppingCategory);
1118        }
1119    }
1120
1121    public void removeAll() throws SystemException {
1122        for (ShoppingCategory shoppingCategory : findAll()) {
1123            remove(shoppingCategory);
1124        }
1125    }
1126
1127    public int countByGroupId(long groupId) throws SystemException {
1128        Object[] finderArgs = new Object[] { new Long(groupId) };
1129
1130        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1131                finderArgs, this);
1132
1133        if (count == null) {
1134            Session session = null;
1135
1136            try {
1137                session = openSession();
1138
1139                StringBundler query = new StringBundler(2);
1140
1141                query.append(_SQL_COUNT_SHOPPINGCATEGORY_WHERE);
1142
1143                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1144
1145                String sql = query.toString();
1146
1147                Query q = session.createQuery(sql);
1148
1149                QueryPos qPos = QueryPos.getInstance(q);
1150
1151                qPos.add(groupId);
1152
1153                count = (Long)q.uniqueResult();
1154            }
1155            catch (Exception e) {
1156                throw processException(e);
1157            }
1158            finally {
1159                if (count == null) {
1160                    count = Long.valueOf(0);
1161                }
1162
1163                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1164                    finderArgs, count);
1165
1166                closeSession(session);
1167            }
1168        }
1169
1170        return count.intValue();
1171    }
1172
1173    public int filterCountByGroupId(long groupId) throws SystemException {
1174        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1175            return countByGroupId(groupId);
1176        }
1177
1178        Session session = null;
1179
1180        try {
1181            session = openSession();
1182
1183            StringBundler query = new StringBundler(2);
1184
1185            query.append(_FILTER_SQL_COUNT_SHOPPINGCATEGORY_WHERE);
1186
1187            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1188
1189            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1190                    ShoppingCategory.class.getName(),
1191                    _FILTER_COLUMN_CATEGORYID, _FILTER_COLUMN_USERID, groupId);
1192
1193            SQLQuery q = session.createSQLQuery(sql);
1194
1195            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
1196
1197            QueryPos qPos = QueryPos.getInstance(q);
1198
1199            qPos.add(groupId);
1200
1201            Long count = (Long)q.uniqueResult();
1202
1203            return count.intValue();
1204        }
1205        catch (Exception e) {
1206            throw processException(e);
1207        }
1208        finally {
1209            closeSession(session);
1210        }
1211    }
1212
1213    public int countByG_P(long groupId, long parentCategoryId)
1214        throws SystemException {
1215        Object[] finderArgs = new Object[] {
1216                new Long(groupId), new Long(parentCategoryId)
1217            };
1218
1219        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P,
1220                finderArgs, this);
1221
1222        if (count == null) {
1223            Session session = null;
1224
1225            try {
1226                session = openSession();
1227
1228                StringBundler query = new StringBundler(3);
1229
1230                query.append(_SQL_COUNT_SHOPPINGCATEGORY_WHERE);
1231
1232                query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1233
1234                query.append(_FINDER_COLUMN_G_P_PARENTCATEGORYID_2);
1235
1236                String sql = query.toString();
1237
1238                Query q = session.createQuery(sql);
1239
1240                QueryPos qPos = QueryPos.getInstance(q);
1241
1242                qPos.add(groupId);
1243
1244                qPos.add(parentCategoryId);
1245
1246                count = (Long)q.uniqueResult();
1247            }
1248            catch (Exception e) {
1249                throw processException(e);
1250            }
1251            finally {
1252                if (count == null) {
1253                    count = Long.valueOf(0);
1254                }
1255
1256                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P, finderArgs,
1257                    count);
1258
1259                closeSession(session);
1260            }
1261        }
1262
1263        return count.intValue();
1264    }
1265
1266    public int filterCountByG_P(long groupId, long parentCategoryId)
1267        throws SystemException {
1268        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1269            return countByG_P(groupId, parentCategoryId);
1270        }
1271
1272        Session session = null;
1273
1274        try {
1275            session = openSession();
1276
1277            StringBundler query = new StringBundler(3);
1278
1279            query.append(_FILTER_SQL_COUNT_SHOPPINGCATEGORY_WHERE);
1280
1281            query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1282
1283            query.append(_FINDER_COLUMN_G_P_PARENTCATEGORYID_2);
1284
1285            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1286                    ShoppingCategory.class.getName(),
1287                    _FILTER_COLUMN_CATEGORYID, _FILTER_COLUMN_USERID, groupId);
1288
1289            SQLQuery q = session.createSQLQuery(sql);
1290
1291            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
1292
1293            QueryPos qPos = QueryPos.getInstance(q);
1294
1295            qPos.add(groupId);
1296
1297            qPos.add(parentCategoryId);
1298
1299            Long count = (Long)q.uniqueResult();
1300
1301            return count.intValue();
1302        }
1303        catch (Exception e) {
1304            throw processException(e);
1305        }
1306        finally {
1307            closeSession(session);
1308        }
1309    }
1310
1311    public int countAll() throws SystemException {
1312        Object[] finderArgs = new Object[0];
1313
1314        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1315                finderArgs, this);
1316
1317        if (count == null) {
1318            Session session = null;
1319
1320            try {
1321                session = openSession();
1322
1323                Query q = session.createQuery(_SQL_COUNT_SHOPPINGCATEGORY);
1324
1325                count = (Long)q.uniqueResult();
1326            }
1327            catch (Exception e) {
1328                throw processException(e);
1329            }
1330            finally {
1331                if (count == null) {
1332                    count = Long.valueOf(0);
1333                }
1334
1335                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1336                    count);
1337
1338                closeSession(session);
1339            }
1340        }
1341
1342        return count.intValue();
1343    }
1344
1345    public void afterPropertiesSet() {
1346        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1347                    com.liferay.portal.util.PropsUtil.get(
1348                        "value.object.listener.com.liferay.portlet.shopping.model.ShoppingCategory")));
1349
1350        if (listenerClassNames.length > 0) {
1351            try {
1352                List<ModelListener<ShoppingCategory>> listenersList = new ArrayList<ModelListener<ShoppingCategory>>();
1353
1354                for (String listenerClassName : listenerClassNames) {
1355                    listenersList.add((ModelListener<ShoppingCategory>)InstanceFactory.newInstance(
1356                            listenerClassName));
1357                }
1358
1359                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1360            }
1361            catch (Exception e) {
1362                _log.error(e);
1363            }
1364        }
1365    }
1366
1367    @BeanReference(type = ShoppingCartPersistence.class)
1368    protected ShoppingCartPersistence shoppingCartPersistence;
1369    @BeanReference(type = ShoppingCategoryPersistence.class)
1370    protected ShoppingCategoryPersistence shoppingCategoryPersistence;
1371    @BeanReference(type = ShoppingCouponPersistence.class)
1372    protected ShoppingCouponPersistence shoppingCouponPersistence;
1373    @BeanReference(type = ShoppingItemPersistence.class)
1374    protected ShoppingItemPersistence shoppingItemPersistence;
1375    @BeanReference(type = ShoppingItemFieldPersistence.class)
1376    protected ShoppingItemFieldPersistence shoppingItemFieldPersistence;
1377    @BeanReference(type = ShoppingItemPricePersistence.class)
1378    protected ShoppingItemPricePersistence shoppingItemPricePersistence;
1379    @BeanReference(type = ShoppingOrderPersistence.class)
1380    protected ShoppingOrderPersistence shoppingOrderPersistence;
1381    @BeanReference(type = ShoppingOrderItemPersistence.class)
1382    protected ShoppingOrderItemPersistence shoppingOrderItemPersistence;
1383    @BeanReference(type = ResourcePersistence.class)
1384    protected ResourcePersistence resourcePersistence;
1385    @BeanReference(type = UserPersistence.class)
1386    protected UserPersistence userPersistence;
1387    private static final String _SQL_SELECT_SHOPPINGCATEGORY = "SELECT shoppingCategory FROM ShoppingCategory shoppingCategory";
1388    private static final String _SQL_SELECT_SHOPPINGCATEGORY_WHERE = "SELECT shoppingCategory FROM ShoppingCategory shoppingCategory WHERE ";
1389    private static final String _SQL_COUNT_SHOPPINGCATEGORY = "SELECT COUNT(shoppingCategory) FROM ShoppingCategory shoppingCategory";
1390    private static final String _SQL_COUNT_SHOPPINGCATEGORY_WHERE = "SELECT COUNT(shoppingCategory) FROM ShoppingCategory shoppingCategory WHERE ";
1391    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "shoppingCategory.groupId = ?";
1392    private static final String _FINDER_COLUMN_G_P_GROUPID_2 = "shoppingCategory.groupId = ? AND ";
1393    private static final String _FINDER_COLUMN_G_P_PARENTCATEGORYID_2 = "shoppingCategory.parentCategoryId = ?";
1394    private static final String _FILTER_SQL_SELECT_SHOPPINGCATEGORY_WHERE = "SELECT DISTINCT {shoppingCategory.*} FROM ShoppingCategory shoppingCategory WHERE ";
1395    private static final String _FILTER_SQL_COUNT_SHOPPINGCATEGORY_WHERE = "SELECT COUNT(DISTINCT shoppingCategory.categoryId) AS COUNT_VALUE FROM ShoppingCategory shoppingCategory WHERE ";
1396    private static final String _FILTER_COLUMN_CATEGORYID = "shoppingCategory.categoryId";
1397    private static final String _FILTER_COLUMN_USERID = "shoppingCategory.userId";
1398    private static final String _FILTER_ENTITY_ALIAS = "shoppingCategory";
1399    private static final String _ORDER_BY_ENTITY_ALIAS = "shoppingCategory.";
1400    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ShoppingCategory exists with the primary key ";
1401    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ShoppingCategory exists with the key {";
1402    private static Log _log = LogFactoryUtil.getLog(ShoppingCategoryPersistenceImpl.class);
1403}