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