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