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.portal.service.persistence;
016    
017    import com.liferay.portal.NoSuchImageException;
018    import com.liferay.portal.NoSuchModelException;
019    import com.liferay.portal.kernel.annotation.BeanReference;
020    import com.liferay.portal.kernel.cache.CacheRegistryUtil;
021    import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
022    import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
023    import com.liferay.portal.kernel.dao.orm.FinderPath;
024    import com.liferay.portal.kernel.dao.orm.Query;
025    import com.liferay.portal.kernel.dao.orm.QueryPos;
026    import com.liferay.portal.kernel.dao.orm.QueryUtil;
027    import com.liferay.portal.kernel.dao.orm.Session;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.log.Log;
030    import com.liferay.portal.kernel.log.LogFactoryUtil;
031    import com.liferay.portal.kernel.util.GetterUtil;
032    import com.liferay.portal.kernel.util.InstanceFactory;
033    import com.liferay.portal.kernel.util.OrderByComparator;
034    import com.liferay.portal.kernel.util.StringBundler;
035    import com.liferay.portal.kernel.util.StringPool;
036    import com.liferay.portal.kernel.util.StringUtil;
037    import com.liferay.portal.model.Image;
038    import com.liferay.portal.model.ModelListener;
039    import com.liferay.portal.model.impl.ImageImpl;
040    import com.liferay.portal.model.impl.ImageModelImpl;
041    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
042    
043    import com.liferay.portlet.imagegallery.service.persistence.IGImagePersistence;
044    
045    import java.io.Serializable;
046    
047    import java.util.ArrayList;
048    import java.util.Collections;
049    import java.util.List;
050    
051    /**
052     * @author    Brian Wing Shun Chan
053     * @see       ImagePersistence
054     * @see       ImageUtil
055     * @generated
056     */
057    public class ImagePersistenceImpl extends BasePersistenceImpl<Image>
058            implements ImagePersistence {
059            public static final String FINDER_CLASS_NAME_ENTITY = ImageImpl.class.getName();
060            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
061                    ".List";
062            public static final FinderPath FINDER_PATH_FIND_BY_LTSIZE = new FinderPath(ImageModelImpl.ENTITY_CACHE_ENABLED,
063                            ImageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
064                            "findByLtSize",
065                            new String[] {
066                                    Integer.class.getName(),
067                                    
068                            "java.lang.Integer", "java.lang.Integer",
069                                    "com.liferay.portal.kernel.util.OrderByComparator"
070                            });
071            public static final FinderPath FINDER_PATH_COUNT_BY_LTSIZE = new FinderPath(ImageModelImpl.ENTITY_CACHE_ENABLED,
072                            ImageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
073                            "countByLtSize", new String[] { Integer.class.getName() });
074            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ImageModelImpl.ENTITY_CACHE_ENABLED,
075                            ImageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
076                            "findAll", new String[0]);
077            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ImageModelImpl.ENTITY_CACHE_ENABLED,
078                            ImageModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
079                            "countAll", new String[0]);
080    
081            public void cacheResult(Image image) {
082                    EntityCacheUtil.putResult(ImageModelImpl.ENTITY_CACHE_ENABLED,
083                            ImageImpl.class, image.getPrimaryKey(), image);
084            }
085    
086            public void cacheResult(List<Image> images) {
087                    for (Image image : images) {
088                            if (EntityCacheUtil.getResult(ImageModelImpl.ENTITY_CACHE_ENABLED,
089                                                    ImageImpl.class, image.getPrimaryKey(), this) == null) {
090                                    cacheResult(image);
091                            }
092                    }
093            }
094    
095            public void clearCache() {
096                    CacheRegistryUtil.clear(ImageImpl.class.getName());
097                    EntityCacheUtil.clearCache(ImageImpl.class.getName());
098                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
099                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
100            }
101    
102            public void clearCache(Image image) {
103                    EntityCacheUtil.removeResult(ImageModelImpl.ENTITY_CACHE_ENABLED,
104                            ImageImpl.class, image.getPrimaryKey());
105            }
106    
107            public Image create(long imageId) {
108                    Image image = new ImageImpl();
109    
110                    image.setNew(true);
111                    image.setPrimaryKey(imageId);
112    
113                    return image;
114            }
115    
116            public Image remove(Serializable primaryKey)
117                    throws NoSuchModelException, SystemException {
118                    return remove(((Long)primaryKey).longValue());
119            }
120    
121            public Image remove(long imageId)
122                    throws NoSuchImageException, SystemException {
123                    Session session = null;
124    
125                    try {
126                            session = openSession();
127    
128                            Image image = (Image)session.get(ImageImpl.class, new Long(imageId));
129    
130                            if (image == null) {
131                                    if (_log.isWarnEnabled()) {
132                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + imageId);
133                                    }
134    
135                                    throw new NoSuchImageException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
136                                            imageId);
137                            }
138    
139                            return remove(image);
140                    }
141                    catch (NoSuchImageException nsee) {
142                            throw nsee;
143                    }
144                    catch (Exception e) {
145                            throw processException(e);
146                    }
147                    finally {
148                            closeSession(session);
149                    }
150            }
151    
152            protected Image removeImpl(Image image) throws SystemException {
153                    image = toUnwrappedModel(image);
154    
155                    Session session = null;
156    
157                    try {
158                            session = openSession();
159    
160                            if (image.isCachedModel() || BatchSessionUtil.isEnabled()) {
161                                    Object staleObject = session.get(ImageImpl.class,
162                                                    image.getPrimaryKeyObj());
163    
164                                    if (staleObject != null) {
165                                            session.evict(staleObject);
166                                    }
167                            }
168    
169                            session.delete(image);
170    
171                            session.flush();
172                    }
173                    catch (Exception e) {
174                            throw processException(e);
175                    }
176                    finally {
177                            closeSession(session);
178                    }
179    
180                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
181    
182                    EntityCacheUtil.removeResult(ImageModelImpl.ENTITY_CACHE_ENABLED,
183                            ImageImpl.class, image.getPrimaryKey());
184    
185                    return image;
186            }
187    
188            public Image updateImpl(com.liferay.portal.model.Image image, boolean merge)
189                    throws SystemException {
190                    image = toUnwrappedModel(image);
191    
192                    Session session = null;
193    
194                    try {
195                            session = openSession();
196    
197                            BatchSessionUtil.update(session, image, merge);
198    
199                            image.setNew(false);
200                    }
201                    catch (Exception e) {
202                            throw processException(e);
203                    }
204                    finally {
205                            closeSession(session);
206                    }
207    
208                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
209    
210                    EntityCacheUtil.putResult(ImageModelImpl.ENTITY_CACHE_ENABLED,
211                            ImageImpl.class, image.getPrimaryKey(), image);
212    
213                    return image;
214            }
215    
216            protected Image toUnwrappedModel(Image image) {
217                    if (image instanceof ImageImpl) {
218                            return image;
219                    }
220    
221                    ImageImpl imageImpl = new ImageImpl();
222    
223                    imageImpl.setNew(image.isNew());
224                    imageImpl.setPrimaryKey(image.getPrimaryKey());
225    
226                    imageImpl.setImageId(image.getImageId());
227                    imageImpl.setModifiedDate(image.getModifiedDate());
228                    imageImpl.setText(image.getText());
229                    imageImpl.setType(image.getType());
230                    imageImpl.setHeight(image.getHeight());
231                    imageImpl.setWidth(image.getWidth());
232                    imageImpl.setSize(image.getSize());
233    
234                    return imageImpl;
235            }
236    
237            public Image findByPrimaryKey(Serializable primaryKey)
238                    throws NoSuchModelException, SystemException {
239                    return findByPrimaryKey(((Long)primaryKey).longValue());
240            }
241    
242            public Image findByPrimaryKey(long imageId)
243                    throws NoSuchImageException, SystemException {
244                    Image image = fetchByPrimaryKey(imageId);
245    
246                    if (image == null) {
247                            if (_log.isWarnEnabled()) {
248                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + imageId);
249                            }
250    
251                            throw new NoSuchImageException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
252                                    imageId);
253                    }
254    
255                    return image;
256            }
257    
258            public Image fetchByPrimaryKey(Serializable primaryKey)
259                    throws SystemException {
260                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
261            }
262    
263            public Image fetchByPrimaryKey(long imageId) throws SystemException {
264                    Image image = (Image)EntityCacheUtil.getResult(ImageModelImpl.ENTITY_CACHE_ENABLED,
265                                    ImageImpl.class, imageId, this);
266    
267                    if (image == null) {
268                            Session session = null;
269    
270                            try {
271                                    session = openSession();
272    
273                                    image = (Image)session.get(ImageImpl.class, new Long(imageId));
274                            }
275                            catch (Exception e) {
276                                    throw processException(e);
277                            }
278                            finally {
279                                    if (image != null) {
280                                            cacheResult(image);
281                                    }
282    
283                                    closeSession(session);
284                            }
285                    }
286    
287                    return image;
288            }
289    
290            public List<Image> findByLtSize(int size) throws SystemException {
291                    return findByLtSize(size, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
292            }
293    
294            public List<Image> findByLtSize(int size, int start, int end)
295                    throws SystemException {
296                    return findByLtSize(size, start, end, null);
297            }
298    
299            public List<Image> findByLtSize(int size, int start, int end,
300                    OrderByComparator orderByComparator) throws SystemException {
301                    Object[] finderArgs = new Object[] {
302                                    size,
303                                    
304                                    String.valueOf(start), String.valueOf(end),
305                                    String.valueOf(orderByComparator)
306                            };
307    
308                    List<Image> list = (List<Image>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_LTSIZE,
309                                    finderArgs, this);
310    
311                    if (list == null) {
312                            Session session = null;
313    
314                            try {
315                                    session = openSession();
316    
317                                    StringBundler query = null;
318    
319                                    if (orderByComparator != null) {
320                                            query = new StringBundler(3 +
321                                                            (orderByComparator.getOrderByFields().length * 3));
322                                    }
323                                    else {
324                                            query = new StringBundler(3);
325                                    }
326    
327                                    query.append(_SQL_SELECT_IMAGE_WHERE);
328    
329                                    query.append(_FINDER_COLUMN_LTSIZE_SIZE_2);
330    
331                                    if (orderByComparator != null) {
332                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
333                                                    orderByComparator);
334                                    }
335    
336                                    else {
337                                            query.append(ImageModelImpl.ORDER_BY_JPQL);
338                                    }
339    
340                                    String sql = query.toString();
341    
342                                    Query q = session.createQuery(sql);
343    
344                                    QueryPos qPos = QueryPos.getInstance(q);
345    
346                                    qPos.add(size);
347    
348                                    list = (List<Image>)QueryUtil.list(q, getDialect(), start, end);
349                            }
350                            catch (Exception e) {
351                                    throw processException(e);
352                            }
353                            finally {
354                                    if (list == null) {
355                                            list = new ArrayList<Image>();
356                                    }
357    
358                                    cacheResult(list);
359    
360                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_LTSIZE,
361                                            finderArgs, list);
362    
363                                    closeSession(session);
364                            }
365                    }
366    
367                    return list;
368            }
369    
370            public Image findByLtSize_First(int size,
371                    OrderByComparator orderByComparator)
372                    throws NoSuchImageException, SystemException {
373                    List<Image> list = findByLtSize(size, 0, 1, orderByComparator);
374    
375                    if (list.isEmpty()) {
376                            StringBundler msg = new StringBundler(4);
377    
378                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
379    
380                            msg.append("size=");
381                            msg.append(size);
382    
383                            msg.append(StringPool.CLOSE_CURLY_BRACE);
384    
385                            throw new NoSuchImageException(msg.toString());
386                    }
387                    else {
388                            return list.get(0);
389                    }
390            }
391    
392            public Image findByLtSize_Last(int size, OrderByComparator orderByComparator)
393                    throws NoSuchImageException, SystemException {
394                    int count = countByLtSize(size);
395    
396                    List<Image> list = findByLtSize(size, count - 1, count,
397                                    orderByComparator);
398    
399                    if (list.isEmpty()) {
400                            StringBundler msg = new StringBundler(4);
401    
402                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
403    
404                            msg.append("size=");
405                            msg.append(size);
406    
407                            msg.append(StringPool.CLOSE_CURLY_BRACE);
408    
409                            throw new NoSuchImageException(msg.toString());
410                    }
411                    else {
412                            return list.get(0);
413                    }
414            }
415    
416            public Image[] findByLtSize_PrevAndNext(long imageId, int size,
417                    OrderByComparator orderByComparator)
418                    throws NoSuchImageException, SystemException {
419                    Image image = findByPrimaryKey(imageId);
420    
421                    Session session = null;
422    
423                    try {
424                            session = openSession();
425    
426                            Image[] array = new ImageImpl[3];
427    
428                            array[0] = getByLtSize_PrevAndNext(session, image, size,
429                                            orderByComparator, true);
430    
431                            array[1] = image;
432    
433                            array[2] = getByLtSize_PrevAndNext(session, image, size,
434                                            orderByComparator, false);
435    
436                            return array;
437                    }
438                    catch (Exception e) {
439                            throw processException(e);
440                    }
441                    finally {
442                            closeSession(session);
443                    }
444            }
445    
446            protected Image getByLtSize_PrevAndNext(Session session, Image image,
447                    int size, OrderByComparator orderByComparator, boolean previous) {
448                    StringBundler query = null;
449    
450                    if (orderByComparator != null) {
451                            query = new StringBundler(6 +
452                                            (orderByComparator.getOrderByFields().length * 6));
453                    }
454                    else {
455                            query = new StringBundler(3);
456                    }
457    
458                    query.append(_SQL_SELECT_IMAGE_WHERE);
459    
460                    query.append(_FINDER_COLUMN_LTSIZE_SIZE_2);
461    
462                    if (orderByComparator != null) {
463                            String[] orderByFields = orderByComparator.getOrderByFields();
464    
465                            if (orderByFields.length > 0) {
466                                    query.append(WHERE_AND);
467                            }
468    
469                            for (int i = 0; i < orderByFields.length; i++) {
470                                    query.append(_ORDER_BY_ENTITY_ALIAS);
471                                    query.append(orderByFields[i]);
472    
473                                    if ((i + 1) < orderByFields.length) {
474                                            if (orderByComparator.isAscending() ^ previous) {
475                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
476                                            }
477                                            else {
478                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
479                                            }
480                                    }
481                                    else {
482                                            if (orderByComparator.isAscending() ^ previous) {
483                                                    query.append(WHERE_GREATER_THAN);
484                                            }
485                                            else {
486                                                    query.append(WHERE_LESSER_THAN);
487                                            }
488                                    }
489                            }
490    
491                            query.append(ORDER_BY_CLAUSE);
492    
493                            for (int i = 0; i < orderByFields.length; i++) {
494                                    query.append(_ORDER_BY_ENTITY_ALIAS);
495                                    query.append(orderByFields[i]);
496    
497                                    if ((i + 1) < orderByFields.length) {
498                                            if (orderByComparator.isAscending() ^ previous) {
499                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
500                                            }
501                                            else {
502                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
503                                            }
504                                    }
505                                    else {
506                                            if (orderByComparator.isAscending() ^ previous) {
507                                                    query.append(ORDER_BY_ASC);
508                                            }
509                                            else {
510                                                    query.append(ORDER_BY_DESC);
511                                            }
512                                    }
513                            }
514                    }
515    
516                    else {
517                            query.append(ImageModelImpl.ORDER_BY_JPQL);
518                    }
519    
520                    String sql = query.toString();
521    
522                    Query q = session.createQuery(sql);
523    
524                    q.setFirstResult(0);
525                    q.setMaxResults(2);
526    
527                    QueryPos qPos = QueryPos.getInstance(q);
528    
529                    qPos.add(size);
530    
531                    if (orderByComparator != null) {
532                            Object[] values = orderByComparator.getOrderByValues(image);
533    
534                            for (Object value : values) {
535                                    qPos.add(value);
536                            }
537                    }
538    
539                    List<Image> list = q.list();
540    
541                    if (list.size() == 2) {
542                            return list.get(1);
543                    }
544                    else {
545                            return null;
546                    }
547            }
548    
549            public List<Image> findAll() throws SystemException {
550                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
551            }
552    
553            public List<Image> findAll(int start, int end) throws SystemException {
554                    return findAll(start, end, null);
555            }
556    
557            public List<Image> findAll(int start, int end,
558                    OrderByComparator orderByComparator) throws SystemException {
559                    Object[] finderArgs = new Object[] {
560                                    String.valueOf(start), String.valueOf(end),
561                                    String.valueOf(orderByComparator)
562                            };
563    
564                    List<Image> list = (List<Image>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
565                                    finderArgs, this);
566    
567                    if (list == null) {
568                            Session session = null;
569    
570                            try {
571                                    session = openSession();
572    
573                                    StringBundler query = null;
574                                    String sql = null;
575    
576                                    if (orderByComparator != null) {
577                                            query = new StringBundler(2 +
578                                                            (orderByComparator.getOrderByFields().length * 3));
579    
580                                            query.append(_SQL_SELECT_IMAGE);
581    
582                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
583                                                    orderByComparator);
584    
585                                            sql = query.toString();
586                                    }
587                                    else {
588                                            sql = _SQL_SELECT_IMAGE.concat(ImageModelImpl.ORDER_BY_JPQL);
589                                    }
590    
591                                    Query q = session.createQuery(sql);
592    
593                                    if (orderByComparator == null) {
594                                            list = (List<Image>)QueryUtil.list(q, getDialect(), start,
595                                                            end, false);
596    
597                                            Collections.sort(list);
598                                    }
599                                    else {
600                                            list = (List<Image>)QueryUtil.list(q, getDialect(), start,
601                                                            end);
602                                    }
603                            }
604                            catch (Exception e) {
605                                    throw processException(e);
606                            }
607                            finally {
608                                    if (list == null) {
609                                            list = new ArrayList<Image>();
610                                    }
611    
612                                    cacheResult(list);
613    
614                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
615    
616                                    closeSession(session);
617                            }
618                    }
619    
620                    return list;
621            }
622    
623            public void removeByLtSize(int size) throws SystemException {
624                    for (Image image : findByLtSize(size)) {
625                            remove(image);
626                    }
627            }
628    
629            public void removeAll() throws SystemException {
630                    for (Image image : findAll()) {
631                            remove(image);
632                    }
633            }
634    
635            public int countByLtSize(int size) throws SystemException {
636                    Object[] finderArgs = new Object[] { size };
637    
638                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_LTSIZE,
639                                    finderArgs, this);
640    
641                    if (count == null) {
642                            Session session = null;
643    
644                            try {
645                                    session = openSession();
646    
647                                    StringBundler query = new StringBundler(2);
648    
649                                    query.append(_SQL_COUNT_IMAGE_WHERE);
650    
651                                    query.append(_FINDER_COLUMN_LTSIZE_SIZE_2);
652    
653                                    String sql = query.toString();
654    
655                                    Query q = session.createQuery(sql);
656    
657                                    QueryPos qPos = QueryPos.getInstance(q);
658    
659                                    qPos.add(size);
660    
661                                    count = (Long)q.uniqueResult();
662                            }
663                            catch (Exception e) {
664                                    throw processException(e);
665                            }
666                            finally {
667                                    if (count == null) {
668                                            count = Long.valueOf(0);
669                                    }
670    
671                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_LTSIZE,
672                                            finderArgs, count);
673    
674                                    closeSession(session);
675                            }
676                    }
677    
678                    return count.intValue();
679            }
680    
681            public int countAll() throws SystemException {
682                    Object[] finderArgs = new Object[0];
683    
684                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
685                                    finderArgs, this);
686    
687                    if (count == null) {
688                            Session session = null;
689    
690                            try {
691                                    session = openSession();
692    
693                                    Query q = session.createQuery(_SQL_COUNT_IMAGE);
694    
695                                    count = (Long)q.uniqueResult();
696                            }
697                            catch (Exception e) {
698                                    throw processException(e);
699                            }
700                            finally {
701                                    if (count == null) {
702                                            count = Long.valueOf(0);
703                                    }
704    
705                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
706                                            count);
707    
708                                    closeSession(session);
709                            }
710                    }
711    
712                    return count.intValue();
713            }
714    
715            public void afterPropertiesSet() {
716                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
717                                            com.liferay.portal.util.PropsUtil.get(
718                                                    "value.object.listener.com.liferay.portal.model.Image")));
719    
720                    if (listenerClassNames.length > 0) {
721                            try {
722                                    List<ModelListener<Image>> listenersList = new ArrayList<ModelListener<Image>>();
723    
724                                    for (String listenerClassName : listenerClassNames) {
725                                            listenersList.add((ModelListener<Image>)InstanceFactory.newInstance(
726                                                            listenerClassName));
727                                    }
728    
729                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
730                            }
731                            catch (Exception e) {
732                                    _log.error(e);
733                            }
734                    }
735            }
736    
737            @BeanReference(type = AccountPersistence.class)
738            protected AccountPersistence accountPersistence;
739            @BeanReference(type = AddressPersistence.class)
740            protected AddressPersistence addressPersistence;
741            @BeanReference(type = BrowserTrackerPersistence.class)
742            protected BrowserTrackerPersistence browserTrackerPersistence;
743            @BeanReference(type = ClassNamePersistence.class)
744            protected ClassNamePersistence classNamePersistence;
745            @BeanReference(type = CompanyPersistence.class)
746            protected CompanyPersistence companyPersistence;
747            @BeanReference(type = ContactPersistence.class)
748            protected ContactPersistence contactPersistence;
749            @BeanReference(type = CountryPersistence.class)
750            protected CountryPersistence countryPersistence;
751            @BeanReference(type = EmailAddressPersistence.class)
752            protected EmailAddressPersistence emailAddressPersistence;
753            @BeanReference(type = GroupPersistence.class)
754            protected GroupPersistence groupPersistence;
755            @BeanReference(type = ImagePersistence.class)
756            protected ImagePersistence imagePersistence;
757            @BeanReference(type = LayoutPersistence.class)
758            protected LayoutPersistence layoutPersistence;
759            @BeanReference(type = LayoutPrototypePersistence.class)
760            protected LayoutPrototypePersistence layoutPrototypePersistence;
761            @BeanReference(type = LayoutSetPersistence.class)
762            protected LayoutSetPersistence layoutSetPersistence;
763            @BeanReference(type = LayoutSetPrototypePersistence.class)
764            protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
765            @BeanReference(type = ListTypePersistence.class)
766            protected ListTypePersistence listTypePersistence;
767            @BeanReference(type = LockPersistence.class)
768            protected LockPersistence lockPersistence;
769            @BeanReference(type = MembershipRequestPersistence.class)
770            protected MembershipRequestPersistence membershipRequestPersistence;
771            @BeanReference(type = OrganizationPersistence.class)
772            protected OrganizationPersistence organizationPersistence;
773            @BeanReference(type = OrgGroupPermissionPersistence.class)
774            protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
775            @BeanReference(type = OrgGroupRolePersistence.class)
776            protected OrgGroupRolePersistence orgGroupRolePersistence;
777            @BeanReference(type = OrgLaborPersistence.class)
778            protected OrgLaborPersistence orgLaborPersistence;
779            @BeanReference(type = PasswordPolicyPersistence.class)
780            protected PasswordPolicyPersistence passwordPolicyPersistence;
781            @BeanReference(type = PasswordPolicyRelPersistence.class)
782            protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
783            @BeanReference(type = PasswordTrackerPersistence.class)
784            protected PasswordTrackerPersistence passwordTrackerPersistence;
785            @BeanReference(type = PermissionPersistence.class)
786            protected PermissionPersistence permissionPersistence;
787            @BeanReference(type = PhonePersistence.class)
788            protected PhonePersistence phonePersistence;
789            @BeanReference(type = PluginSettingPersistence.class)
790            protected PluginSettingPersistence pluginSettingPersistence;
791            @BeanReference(type = PortletPersistence.class)
792            protected PortletPersistence portletPersistence;
793            @BeanReference(type = PortletItemPersistence.class)
794            protected PortletItemPersistence portletItemPersistence;
795            @BeanReference(type = PortletPreferencesPersistence.class)
796            protected PortletPreferencesPersistence portletPreferencesPersistence;
797            @BeanReference(type = RegionPersistence.class)
798            protected RegionPersistence regionPersistence;
799            @BeanReference(type = ReleasePersistence.class)
800            protected ReleasePersistence releasePersistence;
801            @BeanReference(type = ResourcePersistence.class)
802            protected ResourcePersistence resourcePersistence;
803            @BeanReference(type = ResourceActionPersistence.class)
804            protected ResourceActionPersistence resourceActionPersistence;
805            @BeanReference(type = ResourceCodePersistence.class)
806            protected ResourceCodePersistence resourceCodePersistence;
807            @BeanReference(type = ResourcePermissionPersistence.class)
808            protected ResourcePermissionPersistence resourcePermissionPersistence;
809            @BeanReference(type = RolePersistence.class)
810            protected RolePersistence rolePersistence;
811            @BeanReference(type = ServiceComponentPersistence.class)
812            protected ServiceComponentPersistence serviceComponentPersistence;
813            @BeanReference(type = ShardPersistence.class)
814            protected ShardPersistence shardPersistence;
815            @BeanReference(type = SubscriptionPersistence.class)
816            protected SubscriptionPersistence subscriptionPersistence;
817            @BeanReference(type = TicketPersistence.class)
818            protected TicketPersistence ticketPersistence;
819            @BeanReference(type = TeamPersistence.class)
820            protected TeamPersistence teamPersistence;
821            @BeanReference(type = UserPersistence.class)
822            protected UserPersistence userPersistence;
823            @BeanReference(type = UserGroupPersistence.class)
824            protected UserGroupPersistence userGroupPersistence;
825            @BeanReference(type = UserGroupGroupRolePersistence.class)
826            protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
827            @BeanReference(type = UserGroupRolePersistence.class)
828            protected UserGroupRolePersistence userGroupRolePersistence;
829            @BeanReference(type = UserIdMapperPersistence.class)
830            protected UserIdMapperPersistence userIdMapperPersistence;
831            @BeanReference(type = UserTrackerPersistence.class)
832            protected UserTrackerPersistence userTrackerPersistence;
833            @BeanReference(type = UserTrackerPathPersistence.class)
834            protected UserTrackerPathPersistence userTrackerPathPersistence;
835            @BeanReference(type = WebDAVPropsPersistence.class)
836            protected WebDAVPropsPersistence webDAVPropsPersistence;
837            @BeanReference(type = WebsitePersistence.class)
838            protected WebsitePersistence websitePersistence;
839            @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
840            protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
841            @BeanReference(type = WorkflowInstanceLinkPersistence.class)
842            protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
843            @BeanReference(type = IGImagePersistence.class)
844            protected IGImagePersistence igImagePersistence;
845            private static final String _SQL_SELECT_IMAGE = "SELECT image FROM Image image";
846            private static final String _SQL_SELECT_IMAGE_WHERE = "SELECT image FROM Image image WHERE ";
847            private static final String _SQL_COUNT_IMAGE = "SELECT COUNT(image) FROM Image image";
848            private static final String _SQL_COUNT_IMAGE_WHERE = "SELECT COUNT(image) FROM Image image WHERE ";
849            private static final String _FINDER_COLUMN_LTSIZE_SIZE_2 = "image.size < ?";
850            private static final String _ORDER_BY_ENTITY_ALIAS = "image.";
851            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Image exists with the primary key ";
852            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Image exists with the key {";
853            private static Log _log = LogFactoryUtil.getLog(ImagePersistenceImpl.class);
854    }