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.jdbc.MappingSqlQuery;
021    import com.liferay.portal.kernel.dao.jdbc.MappingSqlQueryFactoryUtil;
022    import com.liferay.portal.kernel.dao.jdbc.RowMapper;
023    import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
024    import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
025    import com.liferay.portal.kernel.dao.orm.FinderPath;
026    import com.liferay.portal.kernel.dao.orm.Query;
027    import com.liferay.portal.kernel.dao.orm.QueryPos;
028    import com.liferay.portal.kernel.dao.orm.QueryUtil;
029    import com.liferay.portal.kernel.dao.orm.SQLQuery;
030    import com.liferay.portal.kernel.dao.orm.Session;
031    import com.liferay.portal.kernel.exception.SystemException;
032    import com.liferay.portal.kernel.log.Log;
033    import com.liferay.portal.kernel.log.LogFactoryUtil;
034    import com.liferay.portal.kernel.util.GetterUtil;
035    import com.liferay.portal.kernel.util.InstanceFactory;
036    import com.liferay.portal.kernel.util.OrderByComparator;
037    import com.liferay.portal.kernel.util.StringBundler;
038    import com.liferay.portal.kernel.util.StringPool;
039    import com.liferay.portal.kernel.util.StringUtil;
040    import com.liferay.portal.kernel.util.Validator;
041    import com.liferay.portal.model.ModelListener;
042    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
043    import com.liferay.portal.service.persistence.BatchSessionUtil;
044    import com.liferay.portal.service.persistence.ImagePersistence;
045    import com.liferay.portal.service.persistence.ResourcePersistence;
046    import com.liferay.portal.service.persistence.UserPersistence;
047    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
048    
049    import com.liferay.portlet.shopping.NoSuchItemException;
050    import com.liferay.portlet.shopping.model.ShoppingItem;
051    import com.liferay.portlet.shopping.model.impl.ShoppingItemImpl;
052    import com.liferay.portlet.shopping.model.impl.ShoppingItemModelImpl;
053    
054    import java.io.Serializable;
055    
056    import java.util.ArrayList;
057    import java.util.Collections;
058    import java.util.List;
059    
060    /**
061     * @author    Brian Wing Shun Chan
062     * @see       ShoppingItemPersistence
063     * @see       ShoppingItemUtil
064     * @generated
065     */
066    public class ShoppingItemPersistenceImpl extends BasePersistenceImpl<ShoppingItem>
067            implements ShoppingItemPersistence {
068            public static final String FINDER_CLASS_NAME_ENTITY = ShoppingItemImpl.class.getName();
069            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
070                    ".List";
071            public static final FinderPath FINDER_PATH_FETCH_BY_SMALLIMAGEID = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
072                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED,
073                            FINDER_CLASS_NAME_ENTITY, "fetchBySmallImageId",
074                            new String[] { Long.class.getName() });
075            public static final FinderPath FINDER_PATH_COUNT_BY_SMALLIMAGEID = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
076                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
077                            "countBySmallImageId", new String[] { Long.class.getName() });
078            public static final FinderPath FINDER_PATH_FETCH_BY_MEDIUMIMAGEID = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
079                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED,
080                            FINDER_CLASS_NAME_ENTITY, "fetchByMediumImageId",
081                            new String[] { Long.class.getName() });
082            public static final FinderPath FINDER_PATH_COUNT_BY_MEDIUMIMAGEID = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
083                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
084                            "countByMediumImageId", new String[] { Long.class.getName() });
085            public static final FinderPath FINDER_PATH_FETCH_BY_LARGEIMAGEID = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
086                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED,
087                            FINDER_CLASS_NAME_ENTITY, "fetchByLargeImageId",
088                            new String[] { Long.class.getName() });
089            public static final FinderPath FINDER_PATH_COUNT_BY_LARGEIMAGEID = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
090                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
091                            "countByLargeImageId", new String[] { Long.class.getName() });
092            public static final FinderPath FINDER_PATH_FIND_BY_G_C = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
093                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
094                            "findByG_C",
095                            new String[] {
096                                    Long.class.getName(), Long.class.getName(),
097                                    
098                            "java.lang.Integer", "java.lang.Integer",
099                                    "com.liferay.portal.kernel.util.OrderByComparator"
100                            });
101            public static final FinderPath FINDER_PATH_COUNT_BY_G_C = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
102                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
103                            "countByG_C",
104                            new String[] { Long.class.getName(), Long.class.getName() });
105            public static final FinderPath FINDER_PATH_FETCH_BY_C_S = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
106                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED,
107                            FINDER_CLASS_NAME_ENTITY, "fetchByC_S",
108                            new String[] { Long.class.getName(), String.class.getName() });
109            public static final FinderPath FINDER_PATH_COUNT_BY_C_S = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
110                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
111                            "countByC_S",
112                            new String[] { Long.class.getName(), String.class.getName() });
113            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
114                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
115                            "findAll", new String[0]);
116            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
117                            ShoppingItemModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
118                            "countAll", new String[0]);
119    
120            public void cacheResult(ShoppingItem shoppingItem) {
121                    EntityCacheUtil.putResult(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
122                            ShoppingItemImpl.class, shoppingItem.getPrimaryKey(), shoppingItem);
123    
124                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SMALLIMAGEID,
125                            new Object[] { new Long(shoppingItem.getSmallImageId()) },
126                            shoppingItem);
127    
128                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_MEDIUMIMAGEID,
129                            new Object[] { new Long(shoppingItem.getMediumImageId()) },
130                            shoppingItem);
131    
132                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_LARGEIMAGEID,
133                            new Object[] { new Long(shoppingItem.getLargeImageId()) },
134                            shoppingItem);
135    
136                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_S,
137                            new Object[] {
138                                    new Long(shoppingItem.getCompanyId()),
139                                    
140                            shoppingItem.getSku()
141                            }, shoppingItem);
142            }
143    
144            public void cacheResult(List<ShoppingItem> shoppingItems) {
145                    for (ShoppingItem shoppingItem : shoppingItems) {
146                            if (EntityCacheUtil.getResult(
147                                                    ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
148                                                    ShoppingItemImpl.class, shoppingItem.getPrimaryKey(),
149                                                    this) == null) {
150                                    cacheResult(shoppingItem);
151                            }
152                    }
153            }
154    
155            public void clearCache() {
156                    CacheRegistryUtil.clear(ShoppingItemImpl.class.getName());
157                    EntityCacheUtil.clearCache(ShoppingItemImpl.class.getName());
158                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
159                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
160            }
161    
162            public void clearCache(ShoppingItem shoppingItem) {
163                    EntityCacheUtil.removeResult(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
164                            ShoppingItemImpl.class, shoppingItem.getPrimaryKey());
165    
166                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SMALLIMAGEID,
167                            new Object[] { new Long(shoppingItem.getSmallImageId()) });
168    
169                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_MEDIUMIMAGEID,
170                            new Object[] { new Long(shoppingItem.getMediumImageId()) });
171    
172                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_LARGEIMAGEID,
173                            new Object[] { new Long(shoppingItem.getLargeImageId()) });
174    
175                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_S,
176                            new Object[] {
177                                    new Long(shoppingItem.getCompanyId()),
178                                    
179                            shoppingItem.getSku()
180                            });
181            }
182    
183            public ShoppingItem create(long itemId) {
184                    ShoppingItem shoppingItem = new ShoppingItemImpl();
185    
186                    shoppingItem.setNew(true);
187                    shoppingItem.setPrimaryKey(itemId);
188    
189                    return shoppingItem;
190            }
191    
192            public ShoppingItem remove(Serializable primaryKey)
193                    throws NoSuchModelException, SystemException {
194                    return remove(((Long)primaryKey).longValue());
195            }
196    
197            public ShoppingItem remove(long itemId)
198                    throws NoSuchItemException, SystemException {
199                    Session session = null;
200    
201                    try {
202                            session = openSession();
203    
204                            ShoppingItem shoppingItem = (ShoppingItem)session.get(ShoppingItemImpl.class,
205                                            new Long(itemId));
206    
207                            if (shoppingItem == null) {
208                                    if (_log.isWarnEnabled()) {
209                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + itemId);
210                                    }
211    
212                                    throw new NoSuchItemException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
213                                            itemId);
214                            }
215    
216                            return remove(shoppingItem);
217                    }
218                    catch (NoSuchItemException nsee) {
219                            throw nsee;
220                    }
221                    catch (Exception e) {
222                            throw processException(e);
223                    }
224                    finally {
225                            closeSession(session);
226                    }
227            }
228    
229            protected ShoppingItem removeImpl(ShoppingItem shoppingItem)
230                    throws SystemException {
231                    shoppingItem = toUnwrappedModel(shoppingItem);
232    
233                    Session session = null;
234    
235                    try {
236                            session = openSession();
237    
238                            if (shoppingItem.isCachedModel() || BatchSessionUtil.isEnabled()) {
239                                    Object staleObject = session.get(ShoppingItemImpl.class,
240                                                    shoppingItem.getPrimaryKeyObj());
241    
242                                    if (staleObject != null) {
243                                            session.evict(staleObject);
244                                    }
245                            }
246    
247                            session.delete(shoppingItem);
248    
249                            session.flush();
250                    }
251                    catch (Exception e) {
252                            throw processException(e);
253                    }
254                    finally {
255                            closeSession(session);
256                    }
257    
258                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
259    
260                    ShoppingItemModelImpl shoppingItemModelImpl = (ShoppingItemModelImpl)shoppingItem;
261    
262                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SMALLIMAGEID,
263                            new Object[] {
264                                    new Long(shoppingItemModelImpl.getOriginalSmallImageId())
265                            });
266    
267                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_MEDIUMIMAGEID,
268                            new Object[] {
269                                    new Long(shoppingItemModelImpl.getOriginalMediumImageId())
270                            });
271    
272                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_LARGEIMAGEID,
273                            new Object[] {
274                                    new Long(shoppingItemModelImpl.getOriginalLargeImageId())
275                            });
276    
277                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_S,
278                            new Object[] {
279                                    new Long(shoppingItemModelImpl.getOriginalCompanyId()),
280                                    
281                            shoppingItemModelImpl.getOriginalSku()
282                            });
283    
284                    EntityCacheUtil.removeResult(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
285                            ShoppingItemImpl.class, shoppingItem.getPrimaryKey());
286    
287                    return shoppingItem;
288            }
289    
290            public ShoppingItem updateImpl(
291                    com.liferay.portlet.shopping.model.ShoppingItem shoppingItem,
292                    boolean merge) throws SystemException {
293                    shoppingItem = toUnwrappedModel(shoppingItem);
294    
295                    boolean isNew = shoppingItem.isNew();
296    
297                    ShoppingItemModelImpl shoppingItemModelImpl = (ShoppingItemModelImpl)shoppingItem;
298    
299                    Session session = null;
300    
301                    try {
302                            session = openSession();
303    
304                            BatchSessionUtil.update(session, shoppingItem, merge);
305    
306                            shoppingItem.setNew(false);
307                    }
308                    catch (Exception e) {
309                            throw processException(e);
310                    }
311                    finally {
312                            closeSession(session);
313                    }
314    
315                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
316    
317                    EntityCacheUtil.putResult(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
318                            ShoppingItemImpl.class, shoppingItem.getPrimaryKey(), shoppingItem);
319    
320                    if (!isNew &&
321                                    (shoppingItem.getSmallImageId() != shoppingItemModelImpl.getOriginalSmallImageId())) {
322                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_SMALLIMAGEID,
323                                    new Object[] {
324                                            new Long(shoppingItemModelImpl.getOriginalSmallImageId())
325                                    });
326                    }
327    
328                    if (isNew ||
329                                    (shoppingItem.getSmallImageId() != shoppingItemModelImpl.getOriginalSmallImageId())) {
330                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SMALLIMAGEID,
331                                    new Object[] { new Long(shoppingItem.getSmallImageId()) },
332                                    shoppingItem);
333                    }
334    
335                    if (!isNew &&
336                                    (shoppingItem.getMediumImageId() != shoppingItemModelImpl.getOriginalMediumImageId())) {
337                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_MEDIUMIMAGEID,
338                                    new Object[] {
339                                            new Long(shoppingItemModelImpl.getOriginalMediumImageId())
340                                    });
341                    }
342    
343                    if (isNew ||
344                                    (shoppingItem.getMediumImageId() != shoppingItemModelImpl.getOriginalMediumImageId())) {
345                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_MEDIUMIMAGEID,
346                                    new Object[] { new Long(shoppingItem.getMediumImageId()) },
347                                    shoppingItem);
348                    }
349    
350                    if (!isNew &&
351                                    (shoppingItem.getLargeImageId() != shoppingItemModelImpl.getOriginalLargeImageId())) {
352                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_LARGEIMAGEID,
353                                    new Object[] {
354                                            new Long(shoppingItemModelImpl.getOriginalLargeImageId())
355                                    });
356                    }
357    
358                    if (isNew ||
359                                    (shoppingItem.getLargeImageId() != shoppingItemModelImpl.getOriginalLargeImageId())) {
360                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_LARGEIMAGEID,
361                                    new Object[] { new Long(shoppingItem.getLargeImageId()) },
362                                    shoppingItem);
363                    }
364    
365                    if (!isNew &&
366                                    ((shoppingItem.getCompanyId() != shoppingItemModelImpl.getOriginalCompanyId()) ||
367                                    !Validator.equals(shoppingItem.getSku(),
368                                            shoppingItemModelImpl.getOriginalSku()))) {
369                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_S,
370                                    new Object[] {
371                                            new Long(shoppingItemModelImpl.getOriginalCompanyId()),
372                                            
373                                    shoppingItemModelImpl.getOriginalSku()
374                                    });
375                    }
376    
377                    if (isNew ||
378                                    ((shoppingItem.getCompanyId() != shoppingItemModelImpl.getOriginalCompanyId()) ||
379                                    !Validator.equals(shoppingItem.getSku(),
380                                            shoppingItemModelImpl.getOriginalSku()))) {
381                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_S,
382                                    new Object[] {
383                                            new Long(shoppingItem.getCompanyId()),
384                                            
385                                    shoppingItem.getSku()
386                                    }, shoppingItem);
387                    }
388    
389                    return shoppingItem;
390            }
391    
392            protected ShoppingItem toUnwrappedModel(ShoppingItem shoppingItem) {
393                    if (shoppingItem instanceof ShoppingItemImpl) {
394                            return shoppingItem;
395                    }
396    
397                    ShoppingItemImpl shoppingItemImpl = new ShoppingItemImpl();
398    
399                    shoppingItemImpl.setNew(shoppingItem.isNew());
400                    shoppingItemImpl.setPrimaryKey(shoppingItem.getPrimaryKey());
401    
402                    shoppingItemImpl.setItemId(shoppingItem.getItemId());
403                    shoppingItemImpl.setGroupId(shoppingItem.getGroupId());
404                    shoppingItemImpl.setCompanyId(shoppingItem.getCompanyId());
405                    shoppingItemImpl.setUserId(shoppingItem.getUserId());
406                    shoppingItemImpl.setUserName(shoppingItem.getUserName());
407                    shoppingItemImpl.setCreateDate(shoppingItem.getCreateDate());
408                    shoppingItemImpl.setModifiedDate(shoppingItem.getModifiedDate());
409                    shoppingItemImpl.setCategoryId(shoppingItem.getCategoryId());
410                    shoppingItemImpl.setSku(shoppingItem.getSku());
411                    shoppingItemImpl.setName(shoppingItem.getName());
412                    shoppingItemImpl.setDescription(shoppingItem.getDescription());
413                    shoppingItemImpl.setProperties(shoppingItem.getProperties());
414                    shoppingItemImpl.setFields(shoppingItem.isFields());
415                    shoppingItemImpl.setFieldsQuantities(shoppingItem.getFieldsQuantities());
416                    shoppingItemImpl.setMinQuantity(shoppingItem.getMinQuantity());
417                    shoppingItemImpl.setMaxQuantity(shoppingItem.getMaxQuantity());
418                    shoppingItemImpl.setPrice(shoppingItem.getPrice());
419                    shoppingItemImpl.setDiscount(shoppingItem.getDiscount());
420                    shoppingItemImpl.setTaxable(shoppingItem.isTaxable());
421                    shoppingItemImpl.setShipping(shoppingItem.getShipping());
422                    shoppingItemImpl.setUseShippingFormula(shoppingItem.isUseShippingFormula());
423                    shoppingItemImpl.setRequiresShipping(shoppingItem.isRequiresShipping());
424                    shoppingItemImpl.setStockQuantity(shoppingItem.getStockQuantity());
425                    shoppingItemImpl.setFeatured(shoppingItem.isFeatured());
426                    shoppingItemImpl.setSale(shoppingItem.isSale());
427                    shoppingItemImpl.setSmallImage(shoppingItem.isSmallImage());
428                    shoppingItemImpl.setSmallImageId(shoppingItem.getSmallImageId());
429                    shoppingItemImpl.setSmallImageURL(shoppingItem.getSmallImageURL());
430                    shoppingItemImpl.setMediumImage(shoppingItem.isMediumImage());
431                    shoppingItemImpl.setMediumImageId(shoppingItem.getMediumImageId());
432                    shoppingItemImpl.setMediumImageURL(shoppingItem.getMediumImageURL());
433                    shoppingItemImpl.setLargeImage(shoppingItem.isLargeImage());
434                    shoppingItemImpl.setLargeImageId(shoppingItem.getLargeImageId());
435                    shoppingItemImpl.setLargeImageURL(shoppingItem.getLargeImageURL());
436    
437                    return shoppingItemImpl;
438            }
439    
440            public ShoppingItem findByPrimaryKey(Serializable primaryKey)
441                    throws NoSuchModelException, SystemException {
442                    return findByPrimaryKey(((Long)primaryKey).longValue());
443            }
444    
445            public ShoppingItem findByPrimaryKey(long itemId)
446                    throws NoSuchItemException, SystemException {
447                    ShoppingItem shoppingItem = fetchByPrimaryKey(itemId);
448    
449                    if (shoppingItem == null) {
450                            if (_log.isWarnEnabled()) {
451                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + itemId);
452                            }
453    
454                            throw new NoSuchItemException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
455                                    itemId);
456                    }
457    
458                    return shoppingItem;
459            }
460    
461            public ShoppingItem fetchByPrimaryKey(Serializable primaryKey)
462                    throws SystemException {
463                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
464            }
465    
466            public ShoppingItem fetchByPrimaryKey(long itemId)
467                    throws SystemException {
468                    ShoppingItem shoppingItem = (ShoppingItem)EntityCacheUtil.getResult(ShoppingItemModelImpl.ENTITY_CACHE_ENABLED,
469                                    ShoppingItemImpl.class, itemId, this);
470    
471                    if (shoppingItem == null) {
472                            Session session = null;
473    
474                            try {
475                                    session = openSession();
476    
477                                    shoppingItem = (ShoppingItem)session.get(ShoppingItemImpl.class,
478                                                    new Long(itemId));
479                            }
480                            catch (Exception e) {
481                                    throw processException(e);
482                            }
483                            finally {
484                                    if (shoppingItem != null) {
485                                            cacheResult(shoppingItem);
486                                    }
487    
488                                    closeSession(session);
489                            }
490                    }
491    
492                    return shoppingItem;
493            }
494    
495            public ShoppingItem findBySmallImageId(long smallImageId)
496                    throws NoSuchItemException, SystemException {
497                    ShoppingItem shoppingItem = fetchBySmallImageId(smallImageId);
498    
499                    if (shoppingItem == null) {
500                            StringBundler msg = new StringBundler(4);
501    
502                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
503    
504                            msg.append("smallImageId=");
505                            msg.append(smallImageId);
506    
507                            msg.append(StringPool.CLOSE_CURLY_BRACE);
508    
509                            if (_log.isWarnEnabled()) {
510                                    _log.warn(msg.toString());
511                            }
512    
513                            throw new NoSuchItemException(msg.toString());
514                    }
515    
516                    return shoppingItem;
517            }
518    
519            public ShoppingItem fetchBySmallImageId(long smallImageId)
520                    throws SystemException {
521                    return fetchBySmallImageId(smallImageId, true);
522            }
523    
524            public ShoppingItem fetchBySmallImageId(long smallImageId,
525                    boolean retrieveFromCache) throws SystemException {
526                    Object[] finderArgs = new Object[] { smallImageId };
527    
528                    Object result = null;
529    
530                    if (retrieveFromCache) {
531                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_SMALLIMAGEID,
532                                            finderArgs, this);
533                    }
534    
535                    if (result == null) {
536                            Session session = null;
537    
538                            try {
539                                    session = openSession();
540    
541                                    StringBundler query = new StringBundler(3);
542    
543                                    query.append(_SQL_SELECT_SHOPPINGITEM_WHERE);
544    
545                                    query.append(_FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2);
546    
547                                    query.append(ShoppingItemModelImpl.ORDER_BY_JPQL);
548    
549                                    String sql = query.toString();
550    
551                                    Query q = session.createQuery(sql);
552    
553                                    QueryPos qPos = QueryPos.getInstance(q);
554    
555                                    qPos.add(smallImageId);
556    
557                                    List<ShoppingItem> list = q.list();
558    
559                                    result = list;
560    
561                                    ShoppingItem shoppingItem = null;
562    
563                                    if (list.isEmpty()) {
564                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SMALLIMAGEID,
565                                                    finderArgs, list);
566                                    }
567                                    else {
568                                            shoppingItem = list.get(0);
569    
570                                            cacheResult(shoppingItem);
571    
572                                            if ((shoppingItem.getSmallImageId() != smallImageId)) {
573                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SMALLIMAGEID,
574                                                            finderArgs, shoppingItem);
575                                            }
576                                    }
577    
578                                    return shoppingItem;
579                            }
580                            catch (Exception e) {
581                                    throw processException(e);
582                            }
583                            finally {
584                                    if (result == null) {
585                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_SMALLIMAGEID,
586                                                    finderArgs, new ArrayList<ShoppingItem>());
587                                    }
588    
589                                    closeSession(session);
590                            }
591                    }
592                    else {
593                            if (result instanceof List<?>) {
594                                    return null;
595                            }
596                            else {
597                                    return (ShoppingItem)result;
598                            }
599                    }
600            }
601    
602            public ShoppingItem findByMediumImageId(long mediumImageId)
603                    throws NoSuchItemException, SystemException {
604                    ShoppingItem shoppingItem = fetchByMediumImageId(mediumImageId);
605    
606                    if (shoppingItem == null) {
607                            StringBundler msg = new StringBundler(4);
608    
609                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
610    
611                            msg.append("mediumImageId=");
612                            msg.append(mediumImageId);
613    
614                            msg.append(StringPool.CLOSE_CURLY_BRACE);
615    
616                            if (_log.isWarnEnabled()) {
617                                    _log.warn(msg.toString());
618                            }
619    
620                            throw new NoSuchItemException(msg.toString());
621                    }
622    
623                    return shoppingItem;
624            }
625    
626            public ShoppingItem fetchByMediumImageId(long mediumImageId)
627                    throws SystemException {
628                    return fetchByMediumImageId(mediumImageId, true);
629            }
630    
631            public ShoppingItem fetchByMediumImageId(long mediumImageId,
632                    boolean retrieveFromCache) throws SystemException {
633                    Object[] finderArgs = new Object[] { mediumImageId };
634    
635                    Object result = null;
636    
637                    if (retrieveFromCache) {
638                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_MEDIUMIMAGEID,
639                                            finderArgs, this);
640                    }
641    
642                    if (result == null) {
643                            Session session = null;
644    
645                            try {
646                                    session = openSession();
647    
648                                    StringBundler query = new StringBundler(3);
649    
650                                    query.append(_SQL_SELECT_SHOPPINGITEM_WHERE);
651    
652                                    query.append(_FINDER_COLUMN_MEDIUMIMAGEID_MEDIUMIMAGEID_2);
653    
654                                    query.append(ShoppingItemModelImpl.ORDER_BY_JPQL);
655    
656                                    String sql = query.toString();
657    
658                                    Query q = session.createQuery(sql);
659    
660                                    QueryPos qPos = QueryPos.getInstance(q);
661    
662                                    qPos.add(mediumImageId);
663    
664                                    List<ShoppingItem> list = q.list();
665    
666                                    result = list;
667    
668                                    ShoppingItem shoppingItem = null;
669    
670                                    if (list.isEmpty()) {
671                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_MEDIUMIMAGEID,
672                                                    finderArgs, list);
673                                    }
674                                    else {
675                                            shoppingItem = list.get(0);
676    
677                                            cacheResult(shoppingItem);
678    
679                                            if ((shoppingItem.getMediumImageId() != mediumImageId)) {
680                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_MEDIUMIMAGEID,
681                                                            finderArgs, shoppingItem);
682                                            }
683                                    }
684    
685                                    return shoppingItem;
686                            }
687                            catch (Exception e) {
688                                    throw processException(e);
689                            }
690                            finally {
691                                    if (result == null) {
692                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_MEDIUMIMAGEID,
693                                                    finderArgs, new ArrayList<ShoppingItem>());
694                                    }
695    
696                                    closeSession(session);
697                            }
698                    }
699                    else {
700                            if (result instanceof List<?>) {
701                                    return null;
702                            }
703                            else {
704                                    return (ShoppingItem)result;
705                            }
706                    }
707            }
708    
709            public ShoppingItem findByLargeImageId(long largeImageId)
710                    throws NoSuchItemException, SystemException {
711                    ShoppingItem shoppingItem = fetchByLargeImageId(largeImageId);
712    
713                    if (shoppingItem == null) {
714                            StringBundler msg = new StringBundler(4);
715    
716                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
717    
718                            msg.append("largeImageId=");
719                            msg.append(largeImageId);
720    
721                            msg.append(StringPool.CLOSE_CURLY_BRACE);
722    
723                            if (_log.isWarnEnabled()) {
724                                    _log.warn(msg.toString());
725                            }
726    
727                            throw new NoSuchItemException(msg.toString());
728                    }
729    
730                    return shoppingItem;
731            }
732    
733            public ShoppingItem fetchByLargeImageId(long largeImageId)
734                    throws SystemException {
735                    return fetchByLargeImageId(largeImageId, true);
736            }
737    
738            public ShoppingItem fetchByLargeImageId(long largeImageId,
739                    boolean retrieveFromCache) throws SystemException {
740                    Object[] finderArgs = new Object[] { largeImageId };
741    
742                    Object result = null;
743    
744                    if (retrieveFromCache) {
745                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_LARGEIMAGEID,
746                                            finderArgs, this);
747                    }
748    
749                    if (result == null) {
750                            Session session = null;
751    
752                            try {
753                                    session = openSession();
754    
755                                    StringBundler query = new StringBundler(3);
756    
757                                    query.append(_SQL_SELECT_SHOPPINGITEM_WHERE);
758    
759                                    query.append(_FINDER_COLUMN_LARGEIMAGEID_LARGEIMAGEID_2);
760    
761                                    query.append(ShoppingItemModelImpl.ORDER_BY_JPQL);
762    
763                                    String sql = query.toString();
764    
765                                    Query q = session.createQuery(sql);
766    
767                                    QueryPos qPos = QueryPos.getInstance(q);
768    
769                                    qPos.add(largeImageId);
770    
771                                    List<ShoppingItem> list = q.list();
772    
773                                    result = list;
774    
775                                    ShoppingItem shoppingItem = null;
776    
777                                    if (list.isEmpty()) {
778                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_LARGEIMAGEID,
779                                                    finderArgs, list);
780                                    }
781                                    else {
782                                            shoppingItem = list.get(0);
783    
784                                            cacheResult(shoppingItem);
785    
786                                            if ((shoppingItem.getLargeImageId() != largeImageId)) {
787                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_LARGEIMAGEID,
788                                                            finderArgs, shoppingItem);
789                                            }
790                                    }
791    
792                                    return shoppingItem;
793                            }
794                            catch (Exception e) {
795                                    throw processException(e);
796                            }
797                            finally {
798                                    if (result == null) {
799                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_LARGEIMAGEID,
800                                                    finderArgs, new ArrayList<ShoppingItem>());
801                                    }
802    
803                                    closeSession(session);
804                            }
805                    }
806                    else {
807                            if (result instanceof List<?>) {
808                                    return null;
809                            }
810                            else {
811                                    return (ShoppingItem)result;
812                            }
813                    }
814            }
815    
816            public List<ShoppingItem> findByG_C(long groupId, long categoryId)
817                    throws SystemException {
818                    return findByG_C(groupId, categoryId, QueryUtil.ALL_POS,
819                            QueryUtil.ALL_POS, null);
820            }
821    
822            public List<ShoppingItem> findByG_C(long groupId, long categoryId,
823                    int start, int end) throws SystemException {
824                    return findByG_C(groupId, categoryId, start, end, null);
825            }
826    
827            public List<ShoppingItem> findByG_C(long groupId, long categoryId,
828                    int start, int end, OrderByComparator orderByComparator)
829                    throws SystemException {
830                    Object[] finderArgs = new Object[] {
831                                    groupId, categoryId,
832                                    
833                                    String.valueOf(start), String.valueOf(end),
834                                    String.valueOf(orderByComparator)
835                            };
836    
837                    List<ShoppingItem> list = (List<ShoppingItem>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_C,
838                                    finderArgs, this);
839    
840                    if (list == null) {
841                            Session session = null;
842    
843                            try {
844                                    session = openSession();
845    
846                                    StringBundler query = null;
847    
848                                    if (orderByComparator != null) {
849                                            query = new StringBundler(4 +
850                                                            (orderByComparator.getOrderByFields().length * 3));
851                                    }
852                                    else {
853                                            query = new StringBundler(4);
854                                    }
855    
856                                    query.append(_SQL_SELECT_SHOPPINGITEM_WHERE);
857    
858                                    query.append(_FINDER_COLUMN_G_C_GROUPID_2);
859    
860                                    query.append(_FINDER_COLUMN_G_C_CATEGORYID_2);
861    
862                                    if (orderByComparator != null) {
863                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
864                                                    orderByComparator);
865                                    }
866    
867                                    else {
868                                            query.append(ShoppingItemModelImpl.ORDER_BY_JPQL);
869                                    }
870    
871                                    String sql = query.toString();
872    
873                                    Query q = session.createQuery(sql);
874    
875                                    QueryPos qPos = QueryPos.getInstance(q);
876    
877                                    qPos.add(groupId);
878    
879                                    qPos.add(categoryId);
880    
881                                    list = (List<ShoppingItem>)QueryUtil.list(q, getDialect(),
882                                                    start, end);
883                            }
884                            catch (Exception e) {
885                                    throw processException(e);
886                            }
887                            finally {
888                                    if (list == null) {
889                                            list = new ArrayList<ShoppingItem>();
890                                    }
891    
892                                    cacheResult(list);
893    
894                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_C, finderArgs,
895                                            list);
896    
897                                    closeSession(session);
898                            }
899                    }
900    
901                    return list;
902            }
903    
904            public ShoppingItem findByG_C_First(long groupId, long categoryId,
905                    OrderByComparator orderByComparator)
906                    throws NoSuchItemException, SystemException {
907                    List<ShoppingItem> list = findByG_C(groupId, categoryId, 0, 1,
908                                    orderByComparator);
909    
910                    if (list.isEmpty()) {
911                            StringBundler msg = new StringBundler(6);
912    
913                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
914    
915                            msg.append("groupId=");
916                            msg.append(groupId);
917    
918                            msg.append(", categoryId=");
919                            msg.append(categoryId);
920    
921                            msg.append(StringPool.CLOSE_CURLY_BRACE);
922    
923                            throw new NoSuchItemException(msg.toString());
924                    }
925                    else {
926                            return list.get(0);
927                    }
928            }
929    
930            public ShoppingItem findByG_C_Last(long groupId, long categoryId,
931                    OrderByComparator orderByComparator)
932                    throws NoSuchItemException, SystemException {
933                    int count = countByG_C(groupId, categoryId);
934    
935                    List<ShoppingItem> list = findByG_C(groupId, categoryId, count - 1,
936                                    count, orderByComparator);
937    
938                    if (list.isEmpty()) {
939                            StringBundler msg = new StringBundler(6);
940    
941                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
942    
943                            msg.append("groupId=");
944                            msg.append(groupId);
945    
946                            msg.append(", categoryId=");
947                            msg.append(categoryId);
948    
949                            msg.append(StringPool.CLOSE_CURLY_BRACE);
950    
951                            throw new NoSuchItemException(msg.toString());
952                    }
953                    else {
954                            return list.get(0);
955                    }
956            }
957    
958            public ShoppingItem[] findByG_C_PrevAndNext(long itemId, long groupId,
959                    long categoryId, OrderByComparator orderByComparator)
960                    throws NoSuchItemException, SystemException {
961                    ShoppingItem shoppingItem = findByPrimaryKey(itemId);
962    
963                    Session session = null;
964    
965                    try {
966                            session = openSession();
967    
968                            ShoppingItem[] array = new ShoppingItemImpl[3];
969    
970                            array[0] = getByG_C_PrevAndNext(session, shoppingItem, groupId,
971                                            categoryId, orderByComparator, true);
972    
973                            array[1] = shoppingItem;
974    
975                            array[2] = getByG_C_PrevAndNext(session, shoppingItem, groupId,
976                                            categoryId, orderByComparator, false);
977    
978                            return array;
979                    }
980                    catch (Exception e) {
981                            throw processException(e);
982                    }
983                    finally {
984                            closeSession(session);
985                    }
986            }
987    
988            protected ShoppingItem getByG_C_PrevAndNext(Session session,
989                    ShoppingItem shoppingItem, long groupId, long categoryId,
990                    OrderByComparator orderByComparator, boolean previous) {
991                    StringBundler query = null;
992    
993                    if (orderByComparator != null) {
994                            query = new StringBundler(6 +
995                                            (orderByComparator.getOrderByFields().length * 6));
996                    }
997                    else {
998                            query = new StringBundler(3);
999                    }
1000    
1001                    query.append(_SQL_SELECT_SHOPPINGITEM_WHERE);
1002    
1003                    query.append(_FINDER_COLUMN_G_C_GROUPID_2);
1004    
1005                    query.append(_FINDER_COLUMN_G_C_CATEGORYID_2);
1006    
1007                    if (orderByComparator != null) {
1008                            String[] orderByFields = orderByComparator.getOrderByFields();
1009    
1010                            if (orderByFields.length > 0) {
1011                                    query.append(WHERE_AND);
1012                            }
1013    
1014                            for (int i = 0; i < orderByFields.length; i++) {
1015                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1016                                    query.append(orderByFields[i]);
1017    
1018                                    if ((i + 1) < orderByFields.length) {
1019                                            if (orderByComparator.isAscending() ^ previous) {
1020                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1021                                            }
1022                                            else {
1023                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1024                                            }
1025                                    }
1026                                    else {
1027                                            if (orderByComparator.isAscending() ^ previous) {
1028                                                    query.append(WHERE_GREATER_THAN);
1029                                            }
1030                                            else {
1031                                                    query.append(WHERE_LESSER_THAN);
1032                                            }
1033                                    }
1034                            }
1035    
1036                            query.append(ORDER_BY_CLAUSE);
1037    
1038                            for (int i = 0; i < orderByFields.length; i++) {
1039                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1040                                    query.append(orderByFields[i]);
1041    
1042                                    if ((i + 1) < orderByFields.length) {
1043                                            if (orderByComparator.isAscending() ^ previous) {
1044                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1045                                            }
1046                                            else {
1047                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1048                                            }
1049                                    }
1050                                    else {
1051                                            if (orderByComparator.isAscending() ^ previous) {
1052                                                    query.append(ORDER_BY_ASC);
1053                                            }
1054                                            else {
1055                                                    query.append(ORDER_BY_DESC);
1056                                            }
1057                                    }
1058                            }
1059                    }
1060    
1061                    else {
1062                            query.append(ShoppingItemModelImpl.ORDER_BY_JPQL);
1063                    }
1064    
1065                    String sql = query.toString();
1066    
1067                    Query q = session.createQuery(sql);
1068    
1069                    q.setFirstResult(0);
1070                    q.setMaxResults(2);
1071    
1072                    QueryPos qPos = QueryPos.getInstance(q);
1073    
1074                    qPos.add(groupId);
1075    
1076                    qPos.add(categoryId);
1077    
1078                    if (orderByComparator != null) {
1079                            Object[] values = orderByComparator.getOrderByValues(shoppingItem);
1080    
1081                            for (Object value : values) {
1082                                    qPos.add(value);
1083                            }
1084                    }
1085    
1086                    List<ShoppingItem> list = q.list();
1087    
1088                    if (list.size() == 2) {
1089                            return list.get(1);
1090                    }
1091                    else {
1092                            return null;
1093                    }
1094            }
1095    
1096            public List<ShoppingItem> filterFindByG_C(long groupId, long categoryId)
1097                    throws SystemException {
1098                    return filterFindByG_C(groupId, categoryId, QueryUtil.ALL_POS,
1099                            QueryUtil.ALL_POS, null);
1100            }
1101    
1102            public List<ShoppingItem> filterFindByG_C(long groupId, long categoryId,
1103                    int start, int end) throws SystemException {
1104                    return filterFindByG_C(groupId, categoryId, start, end, null);
1105            }
1106    
1107            public List<ShoppingItem> filterFindByG_C(long groupId, long categoryId,
1108                    int start, int end, OrderByComparator orderByComparator)
1109                    throws SystemException {
1110                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1111                            return findByG_C(groupId, categoryId, start, end, orderByComparator);
1112                    }
1113    
1114                    Session session = null;
1115    
1116                    try {
1117                            session = openSession();
1118    
1119                            StringBundler query = null;
1120    
1121                            if (orderByComparator != null) {
1122                                    query = new StringBundler(4 +
1123                                                    (orderByComparator.getOrderByFields().length * 3));
1124                            }
1125                            else {
1126                                    query = new StringBundler(4);
1127                            }
1128    
1129                            query.append(_FILTER_SQL_SELECT_SHOPPINGITEM_WHERE);
1130    
1131                            query.append(_FINDER_COLUMN_G_C_GROUPID_2);
1132    
1133                            query.append(_FINDER_COLUMN_G_C_CATEGORYID_2);
1134    
1135                            if (orderByComparator != null) {
1136                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1137                                            orderByComparator);
1138                            }
1139    
1140                            else {
1141                                    query.append(ShoppingItemModelImpl.ORDER_BY_JPQL);
1142                            }
1143    
1144                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1145                                            ShoppingItem.class.getName(), _FILTER_COLUMN_PK,
1146                                            _FILTER_COLUMN_USERID, groupId);
1147    
1148                            SQLQuery q = session.createSQLQuery(sql);
1149    
1150                            q.addEntity(_FILTER_ENTITY_ALIAS, ShoppingItemImpl.class);
1151    
1152                            QueryPos qPos = QueryPos.getInstance(q);
1153    
1154                            qPos.add(groupId);
1155    
1156                            qPos.add(categoryId);
1157    
1158                            return (List<ShoppingItem>)QueryUtil.list(q, getDialect(), start,
1159                                    end);
1160                    }
1161                    catch (Exception e) {
1162                            throw processException(e);
1163                    }
1164                    finally {
1165                            closeSession(session);
1166                    }
1167            }
1168    
1169            public ShoppingItem findByC_S(long companyId, String sku)
1170                    throws NoSuchItemException, SystemException {
1171                    ShoppingItem shoppingItem = fetchByC_S(companyId, sku);
1172    
1173                    if (shoppingItem == null) {
1174                            StringBundler msg = new StringBundler(6);
1175    
1176                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1177    
1178                            msg.append("companyId=");
1179                            msg.append(companyId);
1180    
1181                            msg.append(", sku=");
1182                            msg.append(sku);
1183    
1184                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1185    
1186                            if (_log.isWarnEnabled()) {
1187                                    _log.warn(msg.toString());
1188                            }
1189    
1190                            throw new NoSuchItemException(msg.toString());
1191                    }
1192    
1193                    return shoppingItem;
1194            }
1195    
1196            public ShoppingItem fetchByC_S(long companyId, String sku)
1197                    throws SystemException {
1198                    return fetchByC_S(companyId, sku, true);
1199            }
1200    
1201            public ShoppingItem fetchByC_S(long companyId, String sku,
1202                    boolean retrieveFromCache) throws SystemException {
1203                    Object[] finderArgs = new Object[] { companyId, sku };
1204    
1205                    Object result = null;
1206    
1207                    if (retrieveFromCache) {
1208                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_S,
1209                                            finderArgs, this);
1210                    }
1211    
1212                    if (result == null) {
1213                            Session session = null;
1214    
1215                            try {
1216                                    session = openSession();
1217    
1218                                    StringBundler query = new StringBundler(4);
1219    
1220                                    query.append(_SQL_SELECT_SHOPPINGITEM_WHERE);
1221    
1222                                    query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
1223    
1224                                    if (sku == null) {
1225                                            query.append(_FINDER_COLUMN_C_S_SKU_1);
1226                                    }
1227                                    else {
1228                                            if (sku.equals(StringPool.BLANK)) {
1229                                                    query.append(_FINDER_COLUMN_C_S_SKU_3);
1230                                            }
1231                                            else {
1232                                                    query.append(_FINDER_COLUMN_C_S_SKU_2);
1233                                            }
1234                                    }
1235    
1236                                    query.append(ShoppingItemModelImpl.ORDER_BY_JPQL);
1237    
1238                                    String sql = query.toString();
1239    
1240                                    Query q = session.createQuery(sql);
1241    
1242                                    QueryPos qPos = QueryPos.getInstance(q);
1243    
1244                                    qPos.add(companyId);
1245    
1246                                    if (sku != null) {
1247                                            qPos.add(sku);
1248                                    }
1249    
1250                                    List<ShoppingItem> list = q.list();
1251    
1252                                    result = list;
1253    
1254                                    ShoppingItem shoppingItem = null;
1255    
1256                                    if (list.isEmpty()) {
1257                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_S,
1258                                                    finderArgs, list);
1259                                    }
1260                                    else {
1261                                            shoppingItem = list.get(0);
1262    
1263                                            cacheResult(shoppingItem);
1264    
1265                                            if ((shoppingItem.getCompanyId() != companyId) ||
1266                                                            (shoppingItem.getSku() == null) ||
1267                                                            !shoppingItem.getSku().equals(sku)) {
1268                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_S,
1269                                                            finderArgs, shoppingItem);
1270                                            }
1271                                    }
1272    
1273                                    return shoppingItem;
1274                            }
1275                            catch (Exception e) {
1276                                    throw processException(e);
1277                            }
1278                            finally {
1279                                    if (result == null) {
1280                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_S,
1281                                                    finderArgs, new ArrayList<ShoppingItem>());
1282                                    }
1283    
1284                                    closeSession(session);
1285                            }
1286                    }
1287                    else {
1288                            if (result instanceof List<?>) {
1289                                    return null;
1290                            }
1291                            else {
1292                                    return (ShoppingItem)result;
1293                            }
1294                    }
1295            }
1296    
1297            public List<ShoppingItem> findAll() throws SystemException {
1298                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1299            }
1300    
1301            public List<ShoppingItem> findAll(int start, int end)
1302                    throws SystemException {
1303                    return findAll(start, end, null);
1304            }
1305    
1306            public List<ShoppingItem> findAll(int start, int end,
1307                    OrderByComparator orderByComparator) throws SystemException {
1308                    Object[] finderArgs = new Object[] {
1309                                    String.valueOf(start), String.valueOf(end),
1310                                    String.valueOf(orderByComparator)
1311                            };
1312    
1313                    List<ShoppingItem> list = (List<ShoppingItem>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1314                                    finderArgs, this);
1315    
1316                    if (list == null) {
1317                            Session session = null;
1318    
1319                            try {
1320                                    session = openSession();
1321    
1322                                    StringBundler query = null;
1323                                    String sql = null;
1324    
1325                                    if (orderByComparator != null) {
1326                                            query = new StringBundler(2 +
1327                                                            (orderByComparator.getOrderByFields().length * 3));
1328    
1329                                            query.append(_SQL_SELECT_SHOPPINGITEM);
1330    
1331                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1332                                                    orderByComparator);
1333    
1334                                            sql = query.toString();
1335                                    }
1336                                    else {
1337                                            sql = _SQL_SELECT_SHOPPINGITEM.concat(ShoppingItemModelImpl.ORDER_BY_JPQL);
1338                                    }
1339    
1340                                    Query q = session.createQuery(sql);
1341    
1342                                    if (orderByComparator == null) {
1343                                            list = (List<ShoppingItem>)QueryUtil.list(q, getDialect(),
1344                                                            start, end, false);
1345    
1346                                            Collections.sort(list);
1347                                    }
1348                                    else {
1349                                            list = (List<ShoppingItem>)QueryUtil.list(q, getDialect(),
1350                                                            start, end);
1351                                    }
1352                            }
1353                            catch (Exception e) {
1354                                    throw processException(e);
1355                            }
1356                            finally {
1357                                    if (list == null) {
1358                                            list = new ArrayList<ShoppingItem>();
1359                                    }
1360    
1361                                    cacheResult(list);
1362    
1363                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1364    
1365                                    closeSession(session);
1366                            }
1367                    }
1368    
1369                    return list;
1370            }
1371    
1372            public void removeBySmallImageId(long smallImageId)
1373                    throws NoSuchItemException, SystemException {
1374                    ShoppingItem shoppingItem = findBySmallImageId(smallImageId);
1375    
1376                    remove(shoppingItem);
1377            }
1378    
1379            public void removeByMediumImageId(long mediumImageId)
1380                    throws NoSuchItemException, SystemException {
1381                    ShoppingItem shoppingItem = findByMediumImageId(mediumImageId);
1382    
1383                    remove(shoppingItem);
1384            }
1385    
1386            public void removeByLargeImageId(long largeImageId)
1387                    throws NoSuchItemException, SystemException {
1388                    ShoppingItem shoppingItem = findByLargeImageId(largeImageId);
1389    
1390                    remove(shoppingItem);
1391            }
1392    
1393            public void removeByG_C(long groupId, long categoryId)
1394                    throws SystemException {
1395                    for (ShoppingItem shoppingItem : findByG_C(groupId, categoryId)) {
1396                            remove(shoppingItem);
1397                    }
1398            }
1399    
1400            public void removeByC_S(long companyId, String sku)
1401                    throws NoSuchItemException, SystemException {
1402                    ShoppingItem shoppingItem = findByC_S(companyId, sku);
1403    
1404                    remove(shoppingItem);
1405            }
1406    
1407            public void removeAll() throws SystemException {
1408                    for (ShoppingItem shoppingItem : findAll()) {
1409                            remove(shoppingItem);
1410                    }
1411            }
1412    
1413            public int countBySmallImageId(long smallImageId) throws SystemException {
1414                    Object[] finderArgs = new Object[] { smallImageId };
1415    
1416                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_SMALLIMAGEID,
1417                                    finderArgs, this);
1418    
1419                    if (count == null) {
1420                            Session session = null;
1421    
1422                            try {
1423                                    session = openSession();
1424    
1425                                    StringBundler query = new StringBundler(2);
1426    
1427                                    query.append(_SQL_COUNT_SHOPPINGITEM_WHERE);
1428    
1429                                    query.append(_FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2);
1430    
1431                                    String sql = query.toString();
1432    
1433                                    Query q = session.createQuery(sql);
1434    
1435                                    QueryPos qPos = QueryPos.getInstance(q);
1436    
1437                                    qPos.add(smallImageId);
1438    
1439                                    count = (Long)q.uniqueResult();
1440                            }
1441                            catch (Exception e) {
1442                                    throw processException(e);
1443                            }
1444                            finally {
1445                                    if (count == null) {
1446                                            count = Long.valueOf(0);
1447                                    }
1448    
1449                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_SMALLIMAGEID,
1450                                            finderArgs, count);
1451    
1452                                    closeSession(session);
1453                            }
1454                    }
1455    
1456                    return count.intValue();
1457            }
1458    
1459            public int countByMediumImageId(long mediumImageId)
1460                    throws SystemException {
1461                    Object[] finderArgs = new Object[] { mediumImageId };
1462    
1463                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_MEDIUMIMAGEID,
1464                                    finderArgs, this);
1465    
1466                    if (count == null) {
1467                            Session session = null;
1468    
1469                            try {
1470                                    session = openSession();
1471    
1472                                    StringBundler query = new StringBundler(2);
1473    
1474                                    query.append(_SQL_COUNT_SHOPPINGITEM_WHERE);
1475    
1476                                    query.append(_FINDER_COLUMN_MEDIUMIMAGEID_MEDIUMIMAGEID_2);
1477    
1478                                    String sql = query.toString();
1479    
1480                                    Query q = session.createQuery(sql);
1481    
1482                                    QueryPos qPos = QueryPos.getInstance(q);
1483    
1484                                    qPos.add(mediumImageId);
1485    
1486                                    count = (Long)q.uniqueResult();
1487                            }
1488                            catch (Exception e) {
1489                                    throw processException(e);
1490                            }
1491                            finally {
1492                                    if (count == null) {
1493                                            count = Long.valueOf(0);
1494                                    }
1495    
1496                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_MEDIUMIMAGEID,
1497                                            finderArgs, count);
1498    
1499                                    closeSession(session);
1500                            }
1501                    }
1502    
1503                    return count.intValue();
1504            }
1505    
1506            public int countByLargeImageId(long largeImageId) throws SystemException {
1507                    Object[] finderArgs = new Object[] { largeImageId };
1508    
1509                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_LARGEIMAGEID,
1510                                    finderArgs, this);
1511    
1512                    if (count == null) {
1513                            Session session = null;
1514    
1515                            try {
1516                                    session = openSession();
1517    
1518                                    StringBundler query = new StringBundler(2);
1519    
1520                                    query.append(_SQL_COUNT_SHOPPINGITEM_WHERE);
1521    
1522                                    query.append(_FINDER_COLUMN_LARGEIMAGEID_LARGEIMAGEID_2);
1523    
1524                                    String sql = query.toString();
1525    
1526                                    Query q = session.createQuery(sql);
1527    
1528                                    QueryPos qPos = QueryPos.getInstance(q);
1529    
1530                                    qPos.add(largeImageId);
1531    
1532                                    count = (Long)q.uniqueResult();
1533                            }
1534                            catch (Exception e) {
1535                                    throw processException(e);
1536                            }
1537                            finally {
1538                                    if (count == null) {
1539                                            count = Long.valueOf(0);
1540                                    }
1541    
1542                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_LARGEIMAGEID,
1543                                            finderArgs, count);
1544    
1545                                    closeSession(session);
1546                            }
1547                    }
1548    
1549                    return count.intValue();
1550            }
1551    
1552            public int countByG_C(long groupId, long categoryId)
1553                    throws SystemException {
1554                    Object[] finderArgs = new Object[] { groupId, categoryId };
1555    
1556                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_C,
1557                                    finderArgs, this);
1558    
1559                    if (count == null) {
1560                            Session session = null;
1561    
1562                            try {
1563                                    session = openSession();
1564    
1565                                    StringBundler query = new StringBundler(3);
1566    
1567                                    query.append(_SQL_COUNT_SHOPPINGITEM_WHERE);
1568    
1569                                    query.append(_FINDER_COLUMN_G_C_GROUPID_2);
1570    
1571                                    query.append(_FINDER_COLUMN_G_C_CATEGORYID_2);
1572    
1573                                    String sql = query.toString();
1574    
1575                                    Query q = session.createQuery(sql);
1576    
1577                                    QueryPos qPos = QueryPos.getInstance(q);
1578    
1579                                    qPos.add(groupId);
1580    
1581                                    qPos.add(categoryId);
1582    
1583                                    count = (Long)q.uniqueResult();
1584                            }
1585                            catch (Exception e) {
1586                                    throw processException(e);
1587                            }
1588                            finally {
1589                                    if (count == null) {
1590                                            count = Long.valueOf(0);
1591                                    }
1592    
1593                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_C, finderArgs,
1594                                            count);
1595    
1596                                    closeSession(session);
1597                            }
1598                    }
1599    
1600                    return count.intValue();
1601            }
1602    
1603            public int filterCountByG_C(long groupId, long categoryId)
1604                    throws SystemException {
1605                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1606                            return countByG_C(groupId, categoryId);
1607                    }
1608    
1609                    Session session = null;
1610    
1611                    try {
1612                            session = openSession();
1613    
1614                            StringBundler query = new StringBundler(3);
1615    
1616                            query.append(_FILTER_SQL_COUNT_SHOPPINGITEM_WHERE);
1617    
1618                            query.append(_FINDER_COLUMN_G_C_GROUPID_2);
1619    
1620                            query.append(_FINDER_COLUMN_G_C_CATEGORYID_2);
1621    
1622                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1623                                            ShoppingItem.class.getName(), _FILTER_COLUMN_PK,
1624                                            _FILTER_COLUMN_USERID, groupId);
1625    
1626                            SQLQuery q = session.createSQLQuery(sql);
1627    
1628                            q.addScalar(COUNT_COLUMN_NAME,
1629                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
1630    
1631                            QueryPos qPos = QueryPos.getInstance(q);
1632    
1633                            qPos.add(groupId);
1634    
1635                            qPos.add(categoryId);
1636    
1637                            Long count = (Long)q.uniqueResult();
1638    
1639                            return count.intValue();
1640                    }
1641                    catch (Exception e) {
1642                            throw processException(e);
1643                    }
1644                    finally {
1645                            closeSession(session);
1646                    }
1647            }
1648    
1649            public int countByC_S(long companyId, String sku) throws SystemException {
1650                    Object[] finderArgs = new Object[] { companyId, sku };
1651    
1652                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_S,
1653                                    finderArgs, this);
1654    
1655                    if (count == null) {
1656                            Session session = null;
1657    
1658                            try {
1659                                    session = openSession();
1660    
1661                                    StringBundler query = new StringBundler(3);
1662    
1663                                    query.append(_SQL_COUNT_SHOPPINGITEM_WHERE);
1664    
1665                                    query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
1666    
1667                                    if (sku == null) {
1668                                            query.append(_FINDER_COLUMN_C_S_SKU_1);
1669                                    }
1670                                    else {
1671                                            if (sku.equals(StringPool.BLANK)) {
1672                                                    query.append(_FINDER_COLUMN_C_S_SKU_3);
1673                                            }
1674                                            else {
1675                                                    query.append(_FINDER_COLUMN_C_S_SKU_2);
1676                                            }
1677                                    }
1678    
1679                                    String sql = query.toString();
1680    
1681                                    Query q = session.createQuery(sql);
1682    
1683                                    QueryPos qPos = QueryPos.getInstance(q);
1684    
1685                                    qPos.add(companyId);
1686    
1687                                    if (sku != null) {
1688                                            qPos.add(sku);
1689                                    }
1690    
1691                                    count = (Long)q.uniqueResult();
1692                            }
1693                            catch (Exception e) {
1694                                    throw processException(e);
1695                            }
1696                            finally {
1697                                    if (count == null) {
1698                                            count = Long.valueOf(0);
1699                                    }
1700    
1701                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_S, finderArgs,
1702                                            count);
1703    
1704                                    closeSession(session);
1705                            }
1706                    }
1707    
1708                    return count.intValue();
1709            }
1710    
1711            public int countAll() throws SystemException {
1712                    Object[] finderArgs = new Object[0];
1713    
1714                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1715                                    finderArgs, this);
1716    
1717                    if (count == null) {
1718                            Session session = null;
1719    
1720                            try {
1721                                    session = openSession();
1722    
1723                                    Query q = session.createQuery(_SQL_COUNT_SHOPPINGITEM);
1724    
1725                                    count = (Long)q.uniqueResult();
1726                            }
1727                            catch (Exception e) {
1728                                    throw processException(e);
1729                            }
1730                            finally {
1731                                    if (count == null) {
1732                                            count = Long.valueOf(0);
1733                                    }
1734    
1735                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1736                                            count);
1737    
1738                                    closeSession(session);
1739                            }
1740                    }
1741    
1742                    return count.intValue();
1743            }
1744    
1745            public List<com.liferay.portlet.shopping.model.ShoppingItemPrice> getShoppingItemPrices(
1746                    long pk) throws SystemException {
1747                    return getShoppingItemPrices(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1748            }
1749    
1750            public List<com.liferay.portlet.shopping.model.ShoppingItemPrice> getShoppingItemPrices(
1751                    long pk, int start, int end) throws SystemException {
1752                    return getShoppingItemPrices(pk, start, end, null);
1753            }
1754    
1755            public static final FinderPath FINDER_PATH_GET_SHOPPINGITEMPRICES = new FinderPath(com.liferay.portlet.shopping.model.impl.ShoppingItemPriceModelImpl.ENTITY_CACHE_ENABLED,
1756                            com.liferay.portlet.shopping.model.impl.ShoppingItemPriceModelImpl.FINDER_CACHE_ENABLED,
1757                            com.liferay.portlet.shopping.service.persistence.ShoppingItemPricePersistenceImpl.FINDER_CLASS_NAME_LIST,
1758                            "getShoppingItemPrices",
1759                            new String[] {
1760                                    Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
1761                                    "com.liferay.portal.kernel.util.OrderByComparator"
1762                            });
1763    
1764            public List<com.liferay.portlet.shopping.model.ShoppingItemPrice> getShoppingItemPrices(
1765                    long pk, int start, int end, OrderByComparator orderByComparator)
1766                    throws SystemException {
1767                    Object[] finderArgs = new Object[] {
1768                                    pk, String.valueOf(start), String.valueOf(end),
1769                                    String.valueOf(orderByComparator)
1770                            };
1771    
1772                    List<com.liferay.portlet.shopping.model.ShoppingItemPrice> list = (List<com.liferay.portlet.shopping.model.ShoppingItemPrice>)FinderCacheUtil.getResult(FINDER_PATH_GET_SHOPPINGITEMPRICES,
1773                                    finderArgs, this);
1774    
1775                    if (list == null) {
1776                            Session session = null;
1777    
1778                            try {
1779                                    session = openSession();
1780    
1781                                    String sql = null;
1782    
1783                                    if (orderByComparator != null) {
1784                                            sql = _SQL_GETSHOPPINGITEMPRICES.concat(ORDER_BY_CLAUSE)
1785                                                                                                            .concat(orderByComparator.getOrderBy());
1786                                    }
1787                                    else {
1788                                            sql = _SQL_GETSHOPPINGITEMPRICES.concat(com.liferay.portlet.shopping.model.impl.ShoppingItemPriceModelImpl.ORDER_BY_SQL);
1789                                    }
1790    
1791                                    SQLQuery q = session.createSQLQuery(sql);
1792    
1793                                    q.addEntity("ShoppingItemPrice",
1794                                            com.liferay.portlet.shopping.model.impl.ShoppingItemPriceImpl.class);
1795    
1796                                    QueryPos qPos = QueryPos.getInstance(q);
1797    
1798                                    qPos.add(pk);
1799    
1800                                    list = (List<com.liferay.portlet.shopping.model.ShoppingItemPrice>)QueryUtil.list(q,
1801                                                    getDialect(), start, end);
1802                            }
1803                            catch (Exception e) {
1804                                    throw processException(e);
1805                            }
1806                            finally {
1807                                    if (list == null) {
1808                                            list = new ArrayList<com.liferay.portlet.shopping.model.ShoppingItemPrice>();
1809                                    }
1810    
1811                                    shoppingItemPricePersistence.cacheResult(list);
1812    
1813                                    FinderCacheUtil.putResult(FINDER_PATH_GET_SHOPPINGITEMPRICES,
1814                                            finderArgs, list);
1815    
1816                                    closeSession(session);
1817                            }
1818                    }
1819    
1820                    return list;
1821            }
1822    
1823            public static final FinderPath FINDER_PATH_GET_SHOPPINGITEMPRICES_SIZE = new FinderPath(com.liferay.portlet.shopping.model.impl.ShoppingItemPriceModelImpl.ENTITY_CACHE_ENABLED,
1824                            com.liferay.portlet.shopping.model.impl.ShoppingItemPriceModelImpl.FINDER_CACHE_ENABLED,
1825                            com.liferay.portlet.shopping.service.persistence.ShoppingItemPricePersistenceImpl.FINDER_CLASS_NAME_LIST,
1826                            "getShoppingItemPricesSize", new String[] { Long.class.getName() });
1827    
1828            public int getShoppingItemPricesSize(long pk) throws SystemException {
1829                    Object[] finderArgs = new Object[] { pk };
1830    
1831                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_GET_SHOPPINGITEMPRICES_SIZE,
1832                                    finderArgs, this);
1833    
1834                    if (count == null) {
1835                            Session session = null;
1836    
1837                            try {
1838                                    session = openSession();
1839    
1840                                    SQLQuery q = session.createSQLQuery(_SQL_GETSHOPPINGITEMPRICESSIZE);
1841    
1842                                    q.addScalar(COUNT_COLUMN_NAME,
1843                                            com.liferay.portal.kernel.dao.orm.Type.LONG);
1844    
1845                                    QueryPos qPos = QueryPos.getInstance(q);
1846    
1847                                    qPos.add(pk);
1848    
1849                                    count = (Long)q.uniqueResult();
1850                            }
1851                            catch (Exception e) {
1852                                    throw processException(e);
1853                            }
1854                            finally {
1855                                    if (count == null) {
1856                                            count = Long.valueOf(0);
1857                                    }
1858    
1859                                    FinderCacheUtil.putResult(FINDER_PATH_GET_SHOPPINGITEMPRICES_SIZE,
1860                                            finderArgs, count);
1861    
1862                                    closeSession(session);
1863                            }
1864                    }
1865    
1866                    return count.intValue();
1867            }
1868    
1869            public static final FinderPath FINDER_PATH_CONTAINS_SHOPPINGITEMPRICE = new FinderPath(com.liferay.portlet.shopping.model.impl.ShoppingItemPriceModelImpl.ENTITY_CACHE_ENABLED,
1870                            com.liferay.portlet.shopping.model.impl.ShoppingItemPriceModelImpl.FINDER_CACHE_ENABLED,
1871                            com.liferay.portlet.shopping.service.persistence.ShoppingItemPricePersistenceImpl.FINDER_CLASS_NAME_LIST,
1872                            "containsShoppingItemPrice",
1873                            new String[] { Long.class.getName(), Long.class.getName() });
1874    
1875            public boolean containsShoppingItemPrice(long pk, long shoppingItemPricePK)
1876                    throws SystemException {
1877                    Object[] finderArgs = new Object[] { pk, shoppingItemPricePK };
1878    
1879                    Boolean value = (Boolean)FinderCacheUtil.getResult(FINDER_PATH_CONTAINS_SHOPPINGITEMPRICE,
1880                                    finderArgs, this);
1881    
1882                    if (value == null) {
1883                            try {
1884                                    value = Boolean.valueOf(containsShoppingItemPrice.contains(pk,
1885                                                            shoppingItemPricePK));
1886                            }
1887                            catch (Exception e) {
1888                                    throw processException(e);
1889                            }
1890                            finally {
1891                                    if (value == null) {
1892                                            value = Boolean.FALSE;
1893                                    }
1894    
1895                                    FinderCacheUtil.putResult(FINDER_PATH_CONTAINS_SHOPPINGITEMPRICE,
1896                                            finderArgs, value);
1897                            }
1898                    }
1899    
1900                    return value.booleanValue();
1901            }
1902    
1903            public boolean containsShoppingItemPrices(long pk)
1904                    throws SystemException {
1905                    if (getShoppingItemPricesSize(pk) > 0) {
1906                            return true;
1907                    }
1908                    else {
1909                            return false;
1910                    }
1911            }
1912    
1913            public void afterPropertiesSet() {
1914                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1915                                            com.liferay.portal.util.PropsUtil.get(
1916                                                    "value.object.listener.com.liferay.portlet.shopping.model.ShoppingItem")));
1917    
1918                    if (listenerClassNames.length > 0) {
1919                            try {
1920                                    List<ModelListener<ShoppingItem>> listenersList = new ArrayList<ModelListener<ShoppingItem>>();
1921    
1922                                    for (String listenerClassName : listenerClassNames) {
1923                                            listenersList.add((ModelListener<ShoppingItem>)InstanceFactory.newInstance(
1924                                                            listenerClassName));
1925                                    }
1926    
1927                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1928                            }
1929                            catch (Exception e) {
1930                                    _log.error(e);
1931                            }
1932                    }
1933    
1934                    containsShoppingItemPrice = new ContainsShoppingItemPrice(this);
1935            }
1936    
1937            @BeanReference(type = ShoppingCartPersistence.class)
1938            protected ShoppingCartPersistence shoppingCartPersistence;
1939            @BeanReference(type = ShoppingCategoryPersistence.class)
1940            protected ShoppingCategoryPersistence shoppingCategoryPersistence;
1941            @BeanReference(type = ShoppingCouponPersistence.class)
1942            protected ShoppingCouponPersistence shoppingCouponPersistence;
1943            @BeanReference(type = ShoppingItemPersistence.class)
1944            protected ShoppingItemPersistence shoppingItemPersistence;
1945            @BeanReference(type = ShoppingItemFieldPersistence.class)
1946            protected ShoppingItemFieldPersistence shoppingItemFieldPersistence;
1947            @BeanReference(type = ShoppingItemPricePersistence.class)
1948            protected ShoppingItemPricePersistence shoppingItemPricePersistence;
1949            @BeanReference(type = ShoppingOrderPersistence.class)
1950            protected ShoppingOrderPersistence shoppingOrderPersistence;
1951            @BeanReference(type = ShoppingOrderItemPersistence.class)
1952            protected ShoppingOrderItemPersistence shoppingOrderItemPersistence;
1953            @BeanReference(type = ImagePersistence.class)
1954            protected ImagePersistence imagePersistence;
1955            @BeanReference(type = ResourcePersistence.class)
1956            protected ResourcePersistence resourcePersistence;
1957            @BeanReference(type = UserPersistence.class)
1958            protected UserPersistence userPersistence;
1959            protected ContainsShoppingItemPrice containsShoppingItemPrice;
1960    
1961            protected class ContainsShoppingItemPrice {
1962                    protected ContainsShoppingItemPrice(
1963                            ShoppingItemPersistenceImpl persistenceImpl) {
1964                            super();
1965    
1966                            _mappingSqlQuery = MappingSqlQueryFactoryUtil.getMappingSqlQuery(getDataSource(),
1967                                            _SQL_CONTAINSSHOPPINGITEMPRICE,
1968                                            new int[] { java.sql.Types.BIGINT, java.sql.Types.BIGINT },
1969                                            RowMapper.COUNT);
1970                    }
1971    
1972                    protected boolean contains(long itemId, long itemPriceId) {
1973                            List<Integer> results = _mappingSqlQuery.execute(new Object[] {
1974                                                    new Long(itemId), new Long(itemPriceId)
1975                                            });
1976    
1977                            if (results.size() > 0) {
1978                                    Integer count = results.get(0);
1979    
1980                                    if (count.intValue() > 0) {
1981                                            return true;
1982                                    }
1983                            }
1984    
1985                            return false;
1986                    }
1987    
1988                    private MappingSqlQuery<Integer> _mappingSqlQuery;
1989            }
1990    
1991            private static final String _SQL_SELECT_SHOPPINGITEM = "SELECT shoppingItem FROM ShoppingItem shoppingItem";
1992            private static final String _SQL_SELECT_SHOPPINGITEM_WHERE = "SELECT shoppingItem FROM ShoppingItem shoppingItem WHERE ";
1993            private static final String _SQL_COUNT_SHOPPINGITEM = "SELECT COUNT(shoppingItem) FROM ShoppingItem shoppingItem";
1994            private static final String _SQL_COUNT_SHOPPINGITEM_WHERE = "SELECT COUNT(shoppingItem) FROM ShoppingItem shoppingItem WHERE ";
1995            private static final String _SQL_GETSHOPPINGITEMPRICES = "SELECT {ShoppingItemPrice.*} FROM ShoppingItemPrice INNER JOIN ShoppingItem ON (ShoppingItem.itemId = ShoppingItemPrice.itemId) WHERE (ShoppingItem.itemId = ?)";
1996            private static final String _SQL_GETSHOPPINGITEMPRICESSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM ShoppingItemPrice WHERE itemId = ?";
1997            private static final String _SQL_CONTAINSSHOPPINGITEMPRICE = "SELECT COUNT(*) AS COUNT_VALUE FROM ShoppingItemPrice WHERE itemId = ? AND itemPriceId = ?";
1998            private static final String _FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2 = "shoppingItem.smallImageId = ?";
1999            private static final String _FINDER_COLUMN_MEDIUMIMAGEID_MEDIUMIMAGEID_2 = "shoppingItem.mediumImageId = ?";
2000            private static final String _FINDER_COLUMN_LARGEIMAGEID_LARGEIMAGEID_2 = "shoppingItem.largeImageId = ?";
2001            private static final String _FINDER_COLUMN_G_C_GROUPID_2 = "shoppingItem.groupId = ? AND ";
2002            private static final String _FINDER_COLUMN_G_C_CATEGORYID_2 = "shoppingItem.categoryId = ?";
2003            private static final String _FINDER_COLUMN_C_S_COMPANYID_2 = "shoppingItem.companyId = ? AND ";
2004            private static final String _FINDER_COLUMN_C_S_SKU_1 = "shoppingItem.sku IS NULL";
2005            private static final String _FINDER_COLUMN_C_S_SKU_2 = "shoppingItem.sku = ?";
2006            private static final String _FINDER_COLUMN_C_S_SKU_3 = "(shoppingItem.sku IS NULL OR shoppingItem.sku = ?)";
2007            private static final String _FILTER_SQL_SELECT_SHOPPINGITEM_WHERE = "SELECT DISTINCT {shoppingItem.*} FROM ShoppingItem shoppingItem WHERE ";
2008            private static final String _FILTER_SQL_COUNT_SHOPPINGITEM_WHERE = "SELECT COUNT(DISTINCT shoppingItem.itemId) AS COUNT_VALUE FROM ShoppingItem shoppingItem WHERE ";
2009            private static final String _FILTER_COLUMN_PK = "shoppingItem.itemId";
2010            private static final String _FILTER_COLUMN_USERID = "shoppingItem.userId";
2011            private static final String _FILTER_ENTITY_ALIAS = "shoppingItem";
2012            private static final String _ORDER_BY_ENTITY_ALIAS = "shoppingItem.";
2013            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ShoppingItem exists with the primary key ";
2014            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ShoppingItem exists with the key {";
2015            private static Log _log = LogFactoryUtil.getLog(ShoppingItemPersistenceImpl.class);
2016    }