1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    *
5    *
6    *
7    * The contents of this file are subject to the terms of the Liferay Enterprise
8    * Subscription License ("License"). You may not use this file except in
9    * compliance with the License. You can obtain a copy of the License by
10   * contacting Liferay, Inc. See the License for the specific language governing
11   * permissions and limitations under the License, including but not limited to
12   * distribution rights of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portlet.tags.service.persistence;
24  
25  import com.liferay.portal.SystemException;
26  import com.liferay.portal.kernel.annotation.BeanReference;
27  import com.liferay.portal.kernel.cache.CacheRegistry;
28  import com.liferay.portal.kernel.dao.jdbc.MappingSqlQuery;
29  import com.liferay.portal.kernel.dao.jdbc.MappingSqlQueryFactoryUtil;
30  import com.liferay.portal.kernel.dao.jdbc.RowMapper;
31  import com.liferay.portal.kernel.dao.jdbc.SqlUpdate;
32  import com.liferay.portal.kernel.dao.jdbc.SqlUpdateFactoryUtil;
33  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
34  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
35  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
36  import com.liferay.portal.kernel.dao.orm.FinderPath;
37  import com.liferay.portal.kernel.dao.orm.Query;
38  import com.liferay.portal.kernel.dao.orm.QueryPos;
39  import com.liferay.portal.kernel.dao.orm.QueryUtil;
40  import com.liferay.portal.kernel.dao.orm.SQLQuery;
41  import com.liferay.portal.kernel.dao.orm.Session;
42  import com.liferay.portal.kernel.dao.orm.Type;
43  import com.liferay.portal.kernel.log.Log;
44  import com.liferay.portal.kernel.log.LogFactoryUtil;
45  import com.liferay.portal.kernel.util.GetterUtil;
46  import com.liferay.portal.kernel.util.OrderByComparator;
47  import com.liferay.portal.kernel.util.StringPool;
48  import com.liferay.portal.kernel.util.StringUtil;
49  import com.liferay.portal.model.ModelListener;
50  import com.liferay.portal.service.persistence.BatchSessionUtil;
51  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
52  
53  import com.liferay.portlet.tags.NoSuchEntryException;
54  import com.liferay.portlet.tags.model.TagsEntry;
55  import com.liferay.portlet.tags.model.impl.TagsEntryImpl;
56  import com.liferay.portlet.tags.model.impl.TagsEntryModelImpl;
57  
58  import java.sql.Types;
59  
60  import java.util.ArrayList;
61  import java.util.Collections;
62  import java.util.List;
63  
64  /**
65   * <a href="TagsEntryPersistenceImpl.java.html"><b><i>View Source</i></b></a>
66   *
67   * @author Brian Wing Shun Chan
68   *
69   */
70  public class TagsEntryPersistenceImpl extends BasePersistenceImpl
71      implements TagsEntryPersistence {
72      public static final String FINDER_CLASS_NAME_ENTITY = TagsEntryImpl.class.getName();
73      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
74          ".List";
75      public static final FinderPath FINDER_PATH_FIND_BY_VOCABULARYID = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
76              TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
77              "findByVocabularyId", new String[] { Long.class.getName() });
78      public static final FinderPath FINDER_PATH_FIND_BY_OBC_VOCABULARYID = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
79              TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
80              "findByVocabularyId",
81              new String[] {
82                  Long.class.getName(),
83                  
84              "java.lang.Integer", "java.lang.Integer",
85                  "com.liferay.portal.kernel.util.OrderByComparator"
86              });
87      public static final FinderPath FINDER_PATH_COUNT_BY_VOCABULARYID = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
88              TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
89              "countByVocabularyId", new String[] { Long.class.getName() });
90      public static final FinderPath FINDER_PATH_FIND_BY_P_V = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
91              TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
92              "findByP_V",
93              new String[] { Long.class.getName(), Long.class.getName() });
94      public static final FinderPath FINDER_PATH_FIND_BY_OBC_P_V = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
95              TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
96              "findByP_V",
97              new String[] {
98                  Long.class.getName(), Long.class.getName(),
99                  
100             "java.lang.Integer", "java.lang.Integer",
101                 "com.liferay.portal.kernel.util.OrderByComparator"
102             });
103     public static final FinderPath FINDER_PATH_COUNT_BY_P_V = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
104             TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
105             "countByP_V",
106             new String[] { Long.class.getName(), Long.class.getName() });
107     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
108             TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
109             "findAll", new String[0]);
110     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
111             TagsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
112             "countAll", new String[0]);
113 
114     public void cacheResult(TagsEntry tagsEntry) {
115         EntityCacheUtil.putResult(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
116             TagsEntryImpl.class, tagsEntry.getPrimaryKey(), tagsEntry);
117     }
118 
119     public void cacheResult(List<TagsEntry> tagsEntries) {
120         for (TagsEntry tagsEntry : tagsEntries) {
121             if (EntityCacheUtil.getResult(
122                         TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
123                         TagsEntryImpl.class, tagsEntry.getPrimaryKey(), this) == null) {
124                 cacheResult(tagsEntry);
125             }
126         }
127     }
128 
129     public void clearCache() {
130         CacheRegistry.clear(TagsEntryImpl.class.getName());
131         EntityCacheUtil.clearCache(TagsEntryImpl.class.getName());
132         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
133         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
134     }
135 
136     public TagsEntry create(long entryId) {
137         TagsEntry tagsEntry = new TagsEntryImpl();
138 
139         tagsEntry.setNew(true);
140         tagsEntry.setPrimaryKey(entryId);
141 
142         return tagsEntry;
143     }
144 
145     public TagsEntry remove(long entryId)
146         throws NoSuchEntryException, SystemException {
147         Session session = null;
148 
149         try {
150             session = openSession();
151 
152             TagsEntry tagsEntry = (TagsEntry)session.get(TagsEntryImpl.class,
153                     new Long(entryId));
154 
155             if (tagsEntry == null) {
156                 if (_log.isWarnEnabled()) {
157                     _log.warn("No TagsEntry exists with the primary key " +
158                         entryId);
159                 }
160 
161                 throw new NoSuchEntryException(
162                     "No TagsEntry exists with the primary key " + entryId);
163             }
164 
165             return remove(tagsEntry);
166         }
167         catch (NoSuchEntryException nsee) {
168             throw nsee;
169         }
170         catch (Exception e) {
171             throw processException(e);
172         }
173         finally {
174             closeSession(session);
175         }
176     }
177 
178     public TagsEntry remove(TagsEntry tagsEntry) throws SystemException {
179         for (ModelListener<TagsEntry> listener : listeners) {
180             listener.onBeforeRemove(tagsEntry);
181         }
182 
183         tagsEntry = removeImpl(tagsEntry);
184 
185         for (ModelListener<TagsEntry> listener : listeners) {
186             listener.onAfterRemove(tagsEntry);
187         }
188 
189         return tagsEntry;
190     }
191 
192     protected TagsEntry removeImpl(TagsEntry tagsEntry)
193         throws SystemException {
194         try {
195             clearTagsAssets.clear(tagsEntry.getPrimaryKey());
196         }
197         catch (Exception e) {
198             throw processException(e);
199         }
200         finally {
201             FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
202         }
203 
204         Session session = null;
205 
206         try {
207             session = openSession();
208 
209             if (tagsEntry.isCachedModel() || BatchSessionUtil.isEnabled()) {
210                 Object staleObject = session.get(TagsEntryImpl.class,
211                         tagsEntry.getPrimaryKeyObj());
212 
213                 if (staleObject != null) {
214                     session.evict(staleObject);
215                 }
216             }
217 
218             session.delete(tagsEntry);
219 
220             session.flush();
221         }
222         catch (Exception e) {
223             throw processException(e);
224         }
225         finally {
226             closeSession(session);
227         }
228 
229         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
230 
231         EntityCacheUtil.removeResult(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
232             TagsEntryImpl.class, tagsEntry.getPrimaryKey());
233 
234         return tagsEntry;
235     }
236 
237     /**
238      * @deprecated Use <code>update(TagsEntry tagsEntry, boolean merge)</code>.
239      */
240     public TagsEntry update(TagsEntry tagsEntry) throws SystemException {
241         if (_log.isWarnEnabled()) {
242             _log.warn(
243                 "Using the deprecated update(TagsEntry tagsEntry) method. Use update(TagsEntry tagsEntry, boolean merge) instead.");
244         }
245 
246         return update(tagsEntry, false);
247     }
248 
249     /**
250      * Add, update, or merge, the entity. This method also calls the model
251      * listeners to trigger the proper events associated with adding, deleting,
252      * or updating an entity.
253      *
254      * @param        tagsEntry the entity to add, update, or merge
255      * @param        merge boolean value for whether to merge the entity. The
256      *                default value is false. Setting merge to true is more
257      *                expensive and should only be true when tagsEntry is
258      *                transient. See LEP-5473 for a detailed discussion of this
259      *                method.
260      * @return        true if the portlet can be displayed via Ajax
261      */
262     public TagsEntry update(TagsEntry tagsEntry, boolean merge)
263         throws SystemException {
264         boolean isNew = tagsEntry.isNew();
265 
266         for (ModelListener<TagsEntry> listener : listeners) {
267             if (isNew) {
268                 listener.onBeforeCreate(tagsEntry);
269             }
270             else {
271                 listener.onBeforeUpdate(tagsEntry);
272             }
273         }
274 
275         tagsEntry = updateImpl(tagsEntry, merge);
276 
277         for (ModelListener<TagsEntry> listener : listeners) {
278             if (isNew) {
279                 listener.onAfterCreate(tagsEntry);
280             }
281             else {
282                 listener.onAfterUpdate(tagsEntry);
283             }
284         }
285 
286         return tagsEntry;
287     }
288 
289     public TagsEntry updateImpl(
290         com.liferay.portlet.tags.model.TagsEntry tagsEntry, boolean merge)
291         throws SystemException {
292         Session session = null;
293 
294         try {
295             session = openSession();
296 
297             BatchSessionUtil.update(session, tagsEntry, merge);
298 
299             tagsEntry.setNew(false);
300         }
301         catch (Exception e) {
302             throw processException(e);
303         }
304         finally {
305             closeSession(session);
306         }
307 
308         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
309 
310         EntityCacheUtil.putResult(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
311             TagsEntryImpl.class, tagsEntry.getPrimaryKey(), tagsEntry);
312 
313         return tagsEntry;
314     }
315 
316     public TagsEntry findByPrimaryKey(long entryId)
317         throws NoSuchEntryException, SystemException {
318         TagsEntry tagsEntry = fetchByPrimaryKey(entryId);
319 
320         if (tagsEntry == null) {
321             if (_log.isWarnEnabled()) {
322                 _log.warn("No TagsEntry exists with the primary key " +
323                     entryId);
324             }
325 
326             throw new NoSuchEntryException(
327                 "No TagsEntry exists with the primary key " + entryId);
328         }
329 
330         return tagsEntry;
331     }
332 
333     public TagsEntry fetchByPrimaryKey(long entryId) throws SystemException {
334         TagsEntry tagsEntry = (TagsEntry)EntityCacheUtil.getResult(TagsEntryModelImpl.ENTITY_CACHE_ENABLED,
335                 TagsEntryImpl.class, entryId, this);
336 
337         if (tagsEntry == null) {
338             Session session = null;
339 
340             try {
341                 session = openSession();
342 
343                 tagsEntry = (TagsEntry)session.get(TagsEntryImpl.class,
344                         new Long(entryId));
345             }
346             catch (Exception e) {
347                 throw processException(e);
348             }
349             finally {
350                 if (tagsEntry != null) {
351                     cacheResult(tagsEntry);
352                 }
353 
354                 closeSession(session);
355             }
356         }
357 
358         return tagsEntry;
359     }
360 
361     public List<TagsEntry> findByVocabularyId(long vocabularyId)
362         throws SystemException {
363         Object[] finderArgs = new Object[] { new Long(vocabularyId) };
364 
365         List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_VOCABULARYID,
366                 finderArgs, this);
367 
368         if (list == null) {
369             Session session = null;
370 
371             try {
372                 session = openSession();
373 
374                 StringBuilder query = new StringBuilder();
375 
376                 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
377 
378                 query.append("tagsEntry.vocabularyId = ?");
379 
380                 query.append(" ");
381 
382                 query.append("ORDER BY ");
383 
384                 query.append("tagsEntry.name ASC");
385 
386                 Query q = session.createQuery(query.toString());
387 
388                 QueryPos qPos = QueryPos.getInstance(q);
389 
390                 qPos.add(vocabularyId);
391 
392                 list = q.list();
393             }
394             catch (Exception e) {
395                 throw processException(e);
396             }
397             finally {
398                 if (list == null) {
399                     list = new ArrayList<TagsEntry>();
400                 }
401 
402                 cacheResult(list);
403 
404                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_VOCABULARYID,
405                     finderArgs, list);
406 
407                 closeSession(session);
408             }
409         }
410 
411         return list;
412     }
413 
414     public List<TagsEntry> findByVocabularyId(long vocabularyId, int start,
415         int end) throws SystemException {
416         return findByVocabularyId(vocabularyId, start, end, null);
417     }
418 
419     public List<TagsEntry> findByVocabularyId(long vocabularyId, int start,
420         int end, OrderByComparator obc) throws SystemException {
421         Object[] finderArgs = new Object[] {
422                 new Long(vocabularyId),
423                 
424                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
425             };
426 
427         List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_VOCABULARYID,
428                 finderArgs, this);
429 
430         if (list == null) {
431             Session session = null;
432 
433             try {
434                 session = openSession();
435 
436                 StringBuilder query = new StringBuilder();
437 
438                 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
439 
440                 query.append("tagsEntry.vocabularyId = ?");
441 
442                 query.append(" ");
443 
444                 if (obc != null) {
445                     query.append("ORDER BY ");
446 
447                     String[] orderByFields = obc.getOrderByFields();
448 
449                     for (int i = 0; i < orderByFields.length; i++) {
450                         query.append("tagsEntry.");
451                         query.append(orderByFields[i]);
452 
453                         if (obc.isAscending()) {
454                             query.append(" ASC");
455                         }
456                         else {
457                             query.append(" DESC");
458                         }
459 
460                         if ((i + 1) < orderByFields.length) {
461                             query.append(", ");
462                         }
463                     }
464                 }
465 
466                 else {
467                     query.append("ORDER BY ");
468 
469                     query.append("tagsEntry.name ASC");
470                 }
471 
472                 Query q = session.createQuery(query.toString());
473 
474                 QueryPos qPos = QueryPos.getInstance(q);
475 
476                 qPos.add(vocabularyId);
477 
478                 list = (List<TagsEntry>)QueryUtil.list(q, getDialect(), start,
479                         end);
480             }
481             catch (Exception e) {
482                 throw processException(e);
483             }
484             finally {
485                 if (list == null) {
486                     list = new ArrayList<TagsEntry>();
487                 }
488 
489                 cacheResult(list);
490 
491                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_VOCABULARYID,
492                     finderArgs, list);
493 
494                 closeSession(session);
495             }
496         }
497 
498         return list;
499     }
500 
501     public TagsEntry findByVocabularyId_First(long vocabularyId,
502         OrderByComparator obc) throws NoSuchEntryException, SystemException {
503         List<TagsEntry> list = findByVocabularyId(vocabularyId, 0, 1, obc);
504 
505         if (list.isEmpty()) {
506             StringBuilder msg = new StringBuilder();
507 
508             msg.append("No TagsEntry exists with the key {");
509 
510             msg.append("vocabularyId=" + vocabularyId);
511 
512             msg.append(StringPool.CLOSE_CURLY_BRACE);
513 
514             throw new NoSuchEntryException(msg.toString());
515         }
516         else {
517             return list.get(0);
518         }
519     }
520 
521     public TagsEntry findByVocabularyId_Last(long vocabularyId,
522         OrderByComparator obc) throws NoSuchEntryException, SystemException {
523         int count = countByVocabularyId(vocabularyId);
524 
525         List<TagsEntry> list = findByVocabularyId(vocabularyId, count - 1,
526                 count, obc);
527 
528         if (list.isEmpty()) {
529             StringBuilder msg = new StringBuilder();
530 
531             msg.append("No TagsEntry exists with the key {");
532 
533             msg.append("vocabularyId=" + vocabularyId);
534 
535             msg.append(StringPool.CLOSE_CURLY_BRACE);
536 
537             throw new NoSuchEntryException(msg.toString());
538         }
539         else {
540             return list.get(0);
541         }
542     }
543 
544     public TagsEntry[] findByVocabularyId_PrevAndNext(long entryId,
545         long vocabularyId, OrderByComparator obc)
546         throws NoSuchEntryException, SystemException {
547         TagsEntry tagsEntry = findByPrimaryKey(entryId);
548 
549         int count = countByVocabularyId(vocabularyId);
550 
551         Session session = null;
552 
553         try {
554             session = openSession();
555 
556             StringBuilder query = new StringBuilder();
557 
558             query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
559 
560             query.append("tagsEntry.vocabularyId = ?");
561 
562             query.append(" ");
563 
564             if (obc != null) {
565                 query.append("ORDER BY ");
566 
567                 String[] orderByFields = obc.getOrderByFields();
568 
569                 for (int i = 0; i < orderByFields.length; i++) {
570                     query.append("tagsEntry.");
571                     query.append(orderByFields[i]);
572 
573                     if (obc.isAscending()) {
574                         query.append(" ASC");
575                     }
576                     else {
577                         query.append(" DESC");
578                     }
579 
580                     if ((i + 1) < orderByFields.length) {
581                         query.append(", ");
582                     }
583                 }
584             }
585 
586             else {
587                 query.append("ORDER BY ");
588 
589                 query.append("tagsEntry.name ASC");
590             }
591 
592             Query q = session.createQuery(query.toString());
593 
594             QueryPos qPos = QueryPos.getInstance(q);
595 
596             qPos.add(vocabularyId);
597 
598             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
599                     tagsEntry);
600 
601             TagsEntry[] array = new TagsEntryImpl[3];
602 
603             array[0] = (TagsEntry)objArray[0];
604             array[1] = (TagsEntry)objArray[1];
605             array[2] = (TagsEntry)objArray[2];
606 
607             return array;
608         }
609         catch (Exception e) {
610             throw processException(e);
611         }
612         finally {
613             closeSession(session);
614         }
615     }
616 
617     public List<TagsEntry> findByP_V(long parentEntryId, long vocabularyId)
618         throws SystemException {
619         Object[] finderArgs = new Object[] {
620                 new Long(parentEntryId), new Long(vocabularyId)
621             };
622 
623         List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_P_V,
624                 finderArgs, this);
625 
626         if (list == null) {
627             Session session = null;
628 
629             try {
630                 session = openSession();
631 
632                 StringBuilder query = new StringBuilder();
633 
634                 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
635 
636                 query.append("tagsEntry.parentEntryId = ?");
637 
638                 query.append(" AND ");
639 
640                 query.append("tagsEntry.vocabularyId = ?");
641 
642                 query.append(" ");
643 
644                 query.append("ORDER BY ");
645 
646                 query.append("tagsEntry.name ASC");
647 
648                 Query q = session.createQuery(query.toString());
649 
650                 QueryPos qPos = QueryPos.getInstance(q);
651 
652                 qPos.add(parentEntryId);
653 
654                 qPos.add(vocabularyId);
655 
656                 list = q.list();
657             }
658             catch (Exception e) {
659                 throw processException(e);
660             }
661             finally {
662                 if (list == null) {
663                     list = new ArrayList<TagsEntry>();
664                 }
665 
666                 cacheResult(list);
667 
668                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_P_V, finderArgs,
669                     list);
670 
671                 closeSession(session);
672             }
673         }
674 
675         return list;
676     }
677 
678     public List<TagsEntry> findByP_V(long parentEntryId, long vocabularyId,
679         int start, int end) throws SystemException {
680         return findByP_V(parentEntryId, vocabularyId, start, end, null);
681     }
682 
683     public List<TagsEntry> findByP_V(long parentEntryId, long vocabularyId,
684         int start, int end, OrderByComparator obc) throws SystemException {
685         Object[] finderArgs = new Object[] {
686                 new Long(parentEntryId), new Long(vocabularyId),
687                 
688                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
689             };
690 
691         List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_P_V,
692                 finderArgs, this);
693 
694         if (list == null) {
695             Session session = null;
696 
697             try {
698                 session = openSession();
699 
700                 StringBuilder query = new StringBuilder();
701 
702                 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
703 
704                 query.append("tagsEntry.parentEntryId = ?");
705 
706                 query.append(" AND ");
707 
708                 query.append("tagsEntry.vocabularyId = ?");
709 
710                 query.append(" ");
711 
712                 if (obc != null) {
713                     query.append("ORDER BY ");
714 
715                     String[] orderByFields = obc.getOrderByFields();
716 
717                     for (int i = 0; i < orderByFields.length; i++) {
718                         query.append("tagsEntry.");
719                         query.append(orderByFields[i]);
720 
721                         if (obc.isAscending()) {
722                             query.append(" ASC");
723                         }
724                         else {
725                             query.append(" DESC");
726                         }
727 
728                         if ((i + 1) < orderByFields.length) {
729                             query.append(", ");
730                         }
731                     }
732                 }
733 
734                 else {
735                     query.append("ORDER BY ");
736 
737                     query.append("tagsEntry.name ASC");
738                 }
739 
740                 Query q = session.createQuery(query.toString());
741 
742                 QueryPos qPos = QueryPos.getInstance(q);
743 
744                 qPos.add(parentEntryId);
745 
746                 qPos.add(vocabularyId);
747 
748                 list = (List<TagsEntry>)QueryUtil.list(q, getDialect(), start,
749                         end);
750             }
751             catch (Exception e) {
752                 throw processException(e);
753             }
754             finally {
755                 if (list == null) {
756                     list = new ArrayList<TagsEntry>();
757                 }
758 
759                 cacheResult(list);
760 
761                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_P_V,
762                     finderArgs, list);
763 
764                 closeSession(session);
765             }
766         }
767 
768         return list;
769     }
770 
771     public TagsEntry findByP_V_First(long parentEntryId, long vocabularyId,
772         OrderByComparator obc) throws NoSuchEntryException, SystemException {
773         List<TagsEntry> list = findByP_V(parentEntryId, vocabularyId, 0, 1, obc);
774 
775         if (list.isEmpty()) {
776             StringBuilder msg = new StringBuilder();
777 
778             msg.append("No TagsEntry exists with the key {");
779 
780             msg.append("parentEntryId=" + parentEntryId);
781 
782             msg.append(", ");
783             msg.append("vocabularyId=" + vocabularyId);
784 
785             msg.append(StringPool.CLOSE_CURLY_BRACE);
786 
787             throw new NoSuchEntryException(msg.toString());
788         }
789         else {
790             return list.get(0);
791         }
792     }
793 
794     public TagsEntry findByP_V_Last(long parentEntryId, long vocabularyId,
795         OrderByComparator obc) throws NoSuchEntryException, SystemException {
796         int count = countByP_V(parentEntryId, vocabularyId);
797 
798         List<TagsEntry> list = findByP_V(parentEntryId, vocabularyId,
799                 count - 1, count, obc);
800 
801         if (list.isEmpty()) {
802             StringBuilder msg = new StringBuilder();
803 
804             msg.append("No TagsEntry exists with the key {");
805 
806             msg.append("parentEntryId=" + parentEntryId);
807 
808             msg.append(", ");
809             msg.append("vocabularyId=" + vocabularyId);
810 
811             msg.append(StringPool.CLOSE_CURLY_BRACE);
812 
813             throw new NoSuchEntryException(msg.toString());
814         }
815         else {
816             return list.get(0);
817         }
818     }
819 
820     public TagsEntry[] findByP_V_PrevAndNext(long entryId, long parentEntryId,
821         long vocabularyId, OrderByComparator obc)
822         throws NoSuchEntryException, SystemException {
823         TagsEntry tagsEntry = findByPrimaryKey(entryId);
824 
825         int count = countByP_V(parentEntryId, vocabularyId);
826 
827         Session session = null;
828 
829         try {
830             session = openSession();
831 
832             StringBuilder query = new StringBuilder();
833 
834             query.append("SELECT tagsEntry FROM TagsEntry tagsEntry WHERE ");
835 
836             query.append("tagsEntry.parentEntryId = ?");
837 
838             query.append(" AND ");
839 
840             query.append("tagsEntry.vocabularyId = ?");
841 
842             query.append(" ");
843 
844             if (obc != null) {
845                 query.append("ORDER BY ");
846 
847                 String[] orderByFields = obc.getOrderByFields();
848 
849                 for (int i = 0; i < orderByFields.length; i++) {
850                     query.append("tagsEntry.");
851                     query.append(orderByFields[i]);
852 
853                     if (obc.isAscending()) {
854                         query.append(" ASC");
855                     }
856                     else {
857                         query.append(" DESC");
858                     }
859 
860                     if ((i + 1) < orderByFields.length) {
861                         query.append(", ");
862                     }
863                 }
864             }
865 
866             else {
867                 query.append("ORDER BY ");
868 
869                 query.append("tagsEntry.name ASC");
870             }
871 
872             Query q = session.createQuery(query.toString());
873 
874             QueryPos qPos = QueryPos.getInstance(q);
875 
876             qPos.add(parentEntryId);
877 
878             qPos.add(vocabularyId);
879 
880             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
881                     tagsEntry);
882 
883             TagsEntry[] array = new TagsEntryImpl[3];
884 
885             array[0] = (TagsEntry)objArray[0];
886             array[1] = (TagsEntry)objArray[1];
887             array[2] = (TagsEntry)objArray[2];
888 
889             return array;
890         }
891         catch (Exception e) {
892             throw processException(e);
893         }
894         finally {
895             closeSession(session);
896         }
897     }
898 
899     public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
900         throws SystemException {
901         Session session = null;
902 
903         try {
904             session = openSession();
905 
906             dynamicQuery.compile(session);
907 
908             return dynamicQuery.list();
909         }
910         catch (Exception e) {
911             throw processException(e);
912         }
913         finally {
914             closeSession(session);
915         }
916     }
917 
918     public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
919         int start, int end) throws SystemException {
920         Session session = null;
921 
922         try {
923             session = openSession();
924 
925             dynamicQuery.setLimit(start, end);
926 
927             dynamicQuery.compile(session);
928 
929             return dynamicQuery.list();
930         }
931         catch (Exception e) {
932             throw processException(e);
933         }
934         finally {
935             closeSession(session);
936         }
937     }
938 
939     public List<TagsEntry> findAll() throws SystemException {
940         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
941     }
942 
943     public List<TagsEntry> findAll(int start, int end)
944         throws SystemException {
945         return findAll(start, end, null);
946     }
947 
948     public List<TagsEntry> findAll(int start, int end, OrderByComparator obc)
949         throws SystemException {
950         Object[] finderArgs = new Object[] {
951                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
952             };
953 
954         List<TagsEntry> list = (List<TagsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
955                 finderArgs, this);
956 
957         if (list == null) {
958             Session session = null;
959 
960             try {
961                 session = openSession();
962 
963                 StringBuilder query = new StringBuilder();
964 
965                 query.append("SELECT tagsEntry FROM TagsEntry tagsEntry ");
966 
967                 if (obc != null) {
968                     query.append("ORDER BY ");
969 
970                     String[] orderByFields = obc.getOrderByFields();
971 
972                     for (int i = 0; i < orderByFields.length; i++) {
973                         query.append("tagsEntry.");
974                         query.append(orderByFields[i]);
975 
976                         if (obc.isAscending()) {
977                             query.append(" ASC");
978                         }
979                         else {
980                             query.append(" DESC");
981                         }
982 
983                         if ((i + 1) < orderByFields.length) {
984                             query.append(", ");
985                         }
986                     }
987                 }
988 
989                 else {
990                     query.append("ORDER BY ");
991 
992                     query.append("tagsEntry.name ASC");
993                 }
994 
995                 Query q = session.createQuery(query.toString());
996 
997                 if (obc == null) {
998                     list = (List<TagsEntry>)QueryUtil.list(q, getDialect(),
999                             start, end, false);
1000
1001                    Collections.sort(list);
1002                }
1003                else {
1004                    list = (List<TagsEntry>)QueryUtil.list(q, getDialect(),
1005                            start, end);
1006                }
1007            }
1008            catch (Exception e) {
1009                throw processException(e);
1010            }
1011            finally {
1012                if (list == null) {
1013                    list = new ArrayList<TagsEntry>();
1014                }
1015
1016                cacheResult(list);
1017
1018                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1019
1020                closeSession(session);
1021            }
1022        }
1023
1024        return list;
1025    }
1026
1027    public void removeByVocabularyId(long vocabularyId)
1028        throws SystemException {
1029        for (TagsEntry tagsEntry : findByVocabularyId(vocabularyId)) {
1030            remove(tagsEntry);
1031        }
1032    }
1033
1034    public void removeByP_V(long parentEntryId, long vocabularyId)
1035        throws SystemException {
1036        for (TagsEntry tagsEntry : findByP_V(parentEntryId, vocabularyId)) {
1037            remove(tagsEntry);
1038        }
1039    }
1040
1041    public void removeAll() throws SystemException {
1042        for (TagsEntry tagsEntry : findAll()) {
1043            remove(tagsEntry);
1044        }
1045    }
1046
1047    public int countByVocabularyId(long vocabularyId) throws SystemException {
1048        Object[] finderArgs = new Object[] { new Long(vocabularyId) };
1049
1050        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_VOCABULARYID,
1051                finderArgs, this);
1052
1053        if (count == null) {
1054            Session session = null;
1055
1056            try {
1057                session = openSession();
1058
1059                StringBuilder query = new StringBuilder();
1060
1061                query.append("SELECT COUNT(tagsEntry) ");
1062                query.append("FROM TagsEntry tagsEntry WHERE ");
1063
1064                query.append("tagsEntry.vocabularyId = ?");
1065
1066                query.append(" ");
1067
1068                Query q = session.createQuery(query.toString());
1069
1070                QueryPos qPos = QueryPos.getInstance(q);
1071
1072                qPos.add(vocabularyId);
1073
1074                count = (Long)q.uniqueResult();
1075            }
1076            catch (Exception e) {
1077                throw processException(e);
1078            }
1079            finally {
1080                if (count == null) {
1081                    count = Long.valueOf(0);
1082                }
1083
1084                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_VOCABULARYID,
1085                    finderArgs, count);
1086
1087                closeSession(session);
1088            }
1089        }
1090
1091        return count.intValue();
1092    }
1093
1094    public int countByP_V(long parentEntryId, long vocabularyId)
1095        throws SystemException {
1096        Object[] finderArgs = new Object[] {
1097                new Long(parentEntryId), new Long(vocabularyId)
1098            };
1099
1100        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_P_V,
1101                finderArgs, this);
1102
1103        if (count == null) {
1104            Session session = null;
1105
1106            try {
1107                session = openSession();
1108
1109                StringBuilder query = new StringBuilder();
1110
1111                query.append("SELECT COUNT(tagsEntry) ");
1112                query.append("FROM TagsEntry tagsEntry WHERE ");
1113
1114                query.append("tagsEntry.parentEntryId = ?");
1115
1116                query.append(" AND ");
1117
1118                query.append("tagsEntry.vocabularyId = ?");
1119
1120                query.append(" ");
1121
1122                Query q = session.createQuery(query.toString());
1123
1124                QueryPos qPos = QueryPos.getInstance(q);
1125
1126                qPos.add(parentEntryId);
1127
1128                qPos.add(vocabularyId);
1129
1130                count = (Long)q.uniqueResult();
1131            }
1132            catch (Exception e) {
1133                throw processException(e);
1134            }
1135            finally {
1136                if (count == null) {
1137                    count = Long.valueOf(0);
1138                }
1139
1140                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_P_V, finderArgs,
1141                    count);
1142
1143                closeSession(session);
1144            }
1145        }
1146
1147        return count.intValue();
1148    }
1149
1150    public int countAll() throws SystemException {
1151        Object[] finderArgs = new Object[0];
1152
1153        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1154                finderArgs, this);
1155
1156        if (count == null) {
1157            Session session = null;
1158
1159            try {
1160                session = openSession();
1161
1162                Query q = session.createQuery(
1163                        "SELECT COUNT(tagsEntry) FROM TagsEntry tagsEntry");
1164
1165                count = (Long)q.uniqueResult();
1166            }
1167            catch (Exception e) {
1168                throw processException(e);
1169            }
1170            finally {
1171                if (count == null) {
1172                    count = Long.valueOf(0);
1173                }
1174
1175                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1176                    count);
1177
1178                closeSession(session);
1179            }
1180        }
1181
1182        return count.intValue();
1183    }
1184
1185    public List<com.liferay.portlet.tags.model.TagsAsset> getTagsAssets(long pk)
1186        throws SystemException {
1187        return getTagsAssets(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1188    }
1189
1190    public List<com.liferay.portlet.tags.model.TagsAsset> getTagsAssets(
1191        long pk, int start, int end) throws SystemException {
1192        return getTagsAssets(pk, start, end, null);
1193    }
1194
1195    public static final FinderPath FINDER_PATH_GET_TAGSASSETS = new FinderPath(com.liferay.portlet.tags.model.impl.TagsAssetModelImpl.ENTITY_CACHE_ENABLED,
1196            TagsEntryModelImpl.FINDER_CACHE_ENABLED_TAGSASSETS_TAGSENTRIES,
1197            "TagsAssets_TagsEntries", "getTagsAssets",
1198            new String[] {
1199                Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
1200                "com.liferay.portal.kernel.util.OrderByComparator"
1201            });
1202
1203    public List<com.liferay.portlet.tags.model.TagsAsset> getTagsAssets(
1204        long pk, int start, int end, OrderByComparator obc)
1205        throws SystemException {
1206        Object[] finderArgs = new Object[] {
1207                new Long(pk), String.valueOf(start), String.valueOf(end),
1208                String.valueOf(obc)
1209            };
1210
1211        List<com.liferay.portlet.tags.model.TagsAsset> list = (List<com.liferay.portlet.tags.model.TagsAsset>)FinderCacheUtil.getResult(FINDER_PATH_GET_TAGSASSETS,
1212                finderArgs, this);
1213
1214        if (list == null) {
1215            Session session = null;
1216
1217            try {
1218                session = openSession();
1219
1220                StringBuilder sb = new StringBuilder();
1221
1222                sb.append(_SQL_GETTAGSASSETS);
1223
1224                if (obc != null) {
1225                    sb.append("ORDER BY ");
1226                    sb.append(obc.getOrderBy());
1227                }
1228
1229                String sql = sb.toString();
1230
1231                SQLQuery q = session.createSQLQuery(sql);
1232
1233                q.addEntity("TagsAsset",
1234                    com.liferay.portlet.tags.model.impl.TagsAssetImpl.class);
1235
1236                QueryPos qPos = QueryPos.getInstance(q);
1237
1238                qPos.add(pk);
1239
1240                list = (List<com.liferay.portlet.tags.model.TagsAsset>)QueryUtil.list(q,
1241                        getDialect(), start, end);
1242            }
1243            catch (Exception e) {
1244                throw processException(e);
1245            }
1246            finally {
1247                if (list == null) {
1248                    list = new ArrayList<com.liferay.portlet.tags.model.TagsAsset>();
1249                }
1250
1251                tagsAssetPersistence.cacheResult(list);
1252
1253                FinderCacheUtil.putResult(FINDER_PATH_GET_TAGSASSETS,
1254                    finderArgs, list);
1255
1256                closeSession(session);
1257            }
1258        }
1259
1260        return list;
1261    }
1262
1263    public static final FinderPath FINDER_PATH_GET_TAGSASSETS_SIZE = new FinderPath(com.liferay.portlet.tags.model.impl.TagsAssetModelImpl.ENTITY_CACHE_ENABLED,
1264            TagsEntryModelImpl.FINDER_CACHE_ENABLED_TAGSASSETS_TAGSENTRIES,
1265            "TagsAssets_TagsEntries", "getTagsAssetsSize",
1266            new String[] { Long.class.getName() });
1267
1268    public int getTagsAssetsSize(long pk) throws SystemException {
1269        Object[] finderArgs = new Object[] { new Long(pk) };
1270
1271        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_GET_TAGSASSETS_SIZE,
1272                finderArgs, this);
1273
1274        if (count == null) {
1275            Session session = null;
1276
1277            try {
1278                session = openSession();
1279
1280                SQLQuery q = session.createSQLQuery(_SQL_GETTAGSASSETSSIZE);
1281
1282                q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
1283
1284                QueryPos qPos = QueryPos.getInstance(q);
1285
1286                qPos.add(pk);
1287
1288                count = (Long)q.uniqueResult();
1289            }
1290            catch (Exception e) {
1291                throw processException(e);
1292            }
1293            finally {
1294                if (count == null) {
1295                    count = Long.valueOf(0);
1296                }
1297
1298                FinderCacheUtil.putResult(FINDER_PATH_GET_TAGSASSETS_SIZE,
1299                    finderArgs, count);
1300
1301                closeSession(session);
1302            }
1303        }
1304
1305        return count.intValue();
1306    }
1307
1308    public static final FinderPath FINDER_PATH_CONTAINS_TAGSASSET = new FinderPath(com.liferay.portlet.tags.model.impl.TagsAssetModelImpl.ENTITY_CACHE_ENABLED,
1309            TagsEntryModelImpl.FINDER_CACHE_ENABLED_TAGSASSETS_TAGSENTRIES,
1310            "TagsAssets_TagsEntries", "containsTagsAsset",
1311            new String[] { Long.class.getName(), Long.class.getName() });
1312
1313    public boolean containsTagsAsset(long pk, long tagsAssetPK)
1314        throws SystemException {
1315        Object[] finderArgs = new Object[] { new Long(pk), new Long(tagsAssetPK) };
1316
1317        Boolean value = (Boolean)FinderCacheUtil.getResult(FINDER_PATH_CONTAINS_TAGSASSET,
1318                finderArgs, this);
1319
1320        if (value == null) {
1321            try {
1322                value = Boolean.valueOf(containsTagsAsset.contains(pk,
1323                            tagsAssetPK));
1324            }
1325            catch (Exception e) {
1326                throw processException(e);
1327            }
1328            finally {
1329                if (value == null) {
1330                    value = Boolean.FALSE;
1331                }
1332
1333                FinderCacheUtil.putResult(FINDER_PATH_CONTAINS_TAGSASSET,
1334                    finderArgs, value);
1335            }
1336        }
1337
1338        return value.booleanValue();
1339    }
1340
1341    public boolean containsTagsAssets(long pk) throws SystemException {
1342        if (getTagsAssetsSize(pk) > 0) {
1343            return true;
1344        }
1345        else {
1346            return false;
1347        }
1348    }
1349
1350    public void addTagsAsset(long pk, long tagsAssetPK)
1351        throws SystemException {
1352        try {
1353            addTagsAsset.add(pk, tagsAssetPK);
1354        }
1355        catch (Exception e) {
1356            throw processException(e);
1357        }
1358        finally {
1359            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1360        }
1361    }
1362
1363    public void addTagsAsset(long pk,
1364        com.liferay.portlet.tags.model.TagsAsset tagsAsset)
1365        throws SystemException {
1366        try {
1367            addTagsAsset.add(pk, tagsAsset.getPrimaryKey());
1368        }
1369        catch (Exception e) {
1370            throw processException(e);
1371        }
1372        finally {
1373            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1374        }
1375    }
1376
1377    public void addTagsAssets(long pk, long[] tagsAssetPKs)
1378        throws SystemException {
1379        try {
1380            for (long tagsAssetPK : tagsAssetPKs) {
1381                addTagsAsset.add(pk, tagsAssetPK);
1382            }
1383        }
1384        catch (Exception e) {
1385            throw processException(e);
1386        }
1387        finally {
1388            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1389        }
1390    }
1391
1392    public void addTagsAssets(long pk,
1393        List<com.liferay.portlet.tags.model.TagsAsset> tagsAssets)
1394        throws SystemException {
1395        try {
1396            for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1397                addTagsAsset.add(pk, tagsAsset.getPrimaryKey());
1398            }
1399        }
1400        catch (Exception e) {
1401            throw processException(e);
1402        }
1403        finally {
1404            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1405        }
1406    }
1407
1408    public void clearTagsAssets(long pk) throws SystemException {
1409        try {
1410            clearTagsAssets.clear(pk);
1411        }
1412        catch (Exception e) {
1413            throw processException(e);
1414        }
1415        finally {
1416            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1417        }
1418    }
1419
1420    public void removeTagsAsset(long pk, long tagsAssetPK)
1421        throws SystemException {
1422        try {
1423            removeTagsAsset.remove(pk, tagsAssetPK);
1424        }
1425        catch (Exception e) {
1426            throw processException(e);
1427        }
1428        finally {
1429            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1430        }
1431    }
1432
1433    public void removeTagsAsset(long pk,
1434        com.liferay.portlet.tags.model.TagsAsset tagsAsset)
1435        throws SystemException {
1436        try {
1437            removeTagsAsset.remove(pk, tagsAsset.getPrimaryKey());
1438        }
1439        catch (Exception e) {
1440            throw processException(e);
1441        }
1442        finally {
1443            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1444        }
1445    }
1446
1447    public void removeTagsAssets(long pk, long[] tagsAssetPKs)
1448        throws SystemException {
1449        try {
1450            for (long tagsAssetPK : tagsAssetPKs) {
1451                removeTagsAsset.remove(pk, tagsAssetPK);
1452            }
1453        }
1454        catch (Exception e) {
1455            throw processException(e);
1456        }
1457        finally {
1458            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1459        }
1460    }
1461
1462    public void removeTagsAssets(long pk,
1463        List<com.liferay.portlet.tags.model.TagsAsset> tagsAssets)
1464        throws SystemException {
1465        try {
1466            for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1467                removeTagsAsset.remove(pk, tagsAsset.getPrimaryKey());
1468            }
1469        }
1470        catch (Exception e) {
1471            throw processException(e);
1472        }
1473        finally {
1474            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1475        }
1476    }
1477
1478    public void setTagsAssets(long pk, long[] tagsAssetPKs)
1479        throws SystemException {
1480        try {
1481            clearTagsAssets.clear(pk);
1482
1483            for (long tagsAssetPK : tagsAssetPKs) {
1484                addTagsAsset.add(pk, tagsAssetPK);
1485            }
1486        }
1487        catch (Exception e) {
1488            throw processException(e);
1489        }
1490        finally {
1491            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1492        }
1493    }
1494
1495    public void setTagsAssets(long pk,
1496        List<com.liferay.portlet.tags.model.TagsAsset> tagsAssets)
1497        throws SystemException {
1498        try {
1499            clearTagsAssets.clear(pk);
1500
1501            for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1502                addTagsAsset.add(pk, tagsAsset.getPrimaryKey());
1503            }
1504        }
1505        catch (Exception e) {
1506            throw processException(e);
1507        }
1508        finally {
1509            FinderCacheUtil.clearCache("TagsAssets_TagsEntries");
1510        }
1511    }
1512
1513    public void afterPropertiesSet() {
1514        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1515                    com.liferay.portal.util.PropsUtil.get(
1516                        "value.object.listener.com.liferay.portlet.tags.model.TagsEntry")));
1517
1518        if (listenerClassNames.length > 0) {
1519            try {
1520                List<ModelListener<TagsEntry>> listenersList = new ArrayList<ModelListener<TagsEntry>>();
1521
1522                for (String listenerClassName : listenerClassNames) {
1523                    listenersList.add((ModelListener<TagsEntry>)Class.forName(
1524                            listenerClassName).newInstance());
1525                }
1526
1527                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1528            }
1529            catch (Exception e) {
1530                _log.error(e);
1531            }
1532        }
1533
1534        containsTagsAsset = new ContainsTagsAsset(this);
1535
1536        addTagsAsset = new AddTagsAsset(this);
1537        clearTagsAssets = new ClearTagsAssets(this);
1538        removeTagsAsset = new RemoveTagsAsset(this);
1539    }
1540
1541    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsAssetPersistence.impl")
1542    protected com.liferay.portlet.tags.service.persistence.TagsAssetPersistence tagsAssetPersistence;
1543    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsEntryPersistence.impl")
1544    protected com.liferay.portlet.tags.service.persistence.TagsEntryPersistence tagsEntryPersistence;
1545    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsPropertyPersistence.impl")
1546    protected com.liferay.portlet.tags.service.persistence.TagsPropertyPersistence tagsPropertyPersistence;
1547    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsSourcePersistence.impl")
1548    protected com.liferay.portlet.tags.service.persistence.TagsSourcePersistence tagsSourcePersistence;
1549    @BeanReference(name = "com.liferay.portlet.tags.service.persistence.TagsVocabularyPersistence.impl")
1550    protected com.liferay.portlet.tags.service.persistence.TagsVocabularyPersistence tagsVocabularyPersistence;
1551    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence.impl")
1552    protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
1553    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence.impl")
1554    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
1555    protected ContainsTagsAsset containsTagsAsset;
1556    protected AddTagsAsset addTagsAsset;
1557    protected ClearTagsAssets clearTagsAssets;
1558    protected RemoveTagsAsset removeTagsAsset;
1559
1560    protected class ContainsTagsAsset {
1561        protected ContainsTagsAsset(TagsEntryPersistenceImpl persistenceImpl) {
1562            super();
1563
1564            _mappingSqlQuery = MappingSqlQueryFactoryUtil.getMappingSqlQuery(getDataSource(),
1565                    _SQL_CONTAINSTAGSASSET,
1566                    new int[] { Types.BIGINT, Types.BIGINT }, RowMapper.COUNT);
1567        }
1568
1569        protected boolean contains(long entryId, long assetId) {
1570            List<Integer> results = _mappingSqlQuery.execute(new Object[] {
1571                        new Long(entryId), new Long(assetId)
1572                    });
1573
1574            if (results.size() > 0) {
1575                Integer count = results.get(0);
1576
1577                if (count.intValue() > 0) {
1578                    return true;
1579                }
1580            }
1581
1582            return false;
1583        }
1584
1585        private MappingSqlQuery _mappingSqlQuery;
1586    }
1587
1588    protected class AddTagsAsset {
1589        protected AddTagsAsset(TagsEntryPersistenceImpl persistenceImpl) {
1590            _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
1591                    "INSERT INTO TagsAssets_TagsEntries (entryId, assetId) VALUES (?, ?)",
1592                    new int[] { Types.BIGINT, Types.BIGINT });
1593            _persistenceImpl = persistenceImpl;
1594        }
1595
1596        protected void add(long entryId, long assetId)
1597            throws SystemException {
1598            if (!_persistenceImpl.containsTagsAsset.contains(entryId, assetId)) {
1599                ModelListener<com.liferay.portlet.tags.model.TagsAsset>[] tagsAssetListeners =
1600                    tagsAssetPersistence.getListeners();
1601
1602                for (ModelListener<TagsEntry> listener : listeners) {
1603                    listener.onBeforeAddAssociation(entryId,
1604                        com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1605                        assetId);
1606                }
1607
1608                for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1609                    listener.onBeforeAddAssociation(assetId,
1610                        TagsEntry.class.getName(), entryId);
1611                }
1612
1613                _sqlUpdate.update(new Object[] {
1614                        new Long(entryId), new Long(assetId)
1615                    });
1616
1617                for (ModelListener<TagsEntry> listener : listeners) {
1618                    listener.onAfterAddAssociation(entryId,
1619                        com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1620                        assetId);
1621                }
1622
1623                for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1624                    listener.onAfterAddAssociation(assetId,
1625                        TagsEntry.class.getName(), entryId);
1626                }
1627            }
1628        }
1629
1630        private SqlUpdate _sqlUpdate;
1631        private TagsEntryPersistenceImpl _persistenceImpl;
1632    }
1633
1634    protected class ClearTagsAssets {
1635        protected ClearTagsAssets(TagsEntryPersistenceImpl persistenceImpl) {
1636            _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
1637                    "DELETE FROM TagsAssets_TagsEntries WHERE entryId = ?",
1638                    new int[] { Types.BIGINT });
1639        }
1640
1641        protected void clear(long entryId) throws SystemException {
1642            ModelListener<com.liferay.portlet.tags.model.TagsAsset>[] tagsAssetListeners =
1643                tagsAssetPersistence.getListeners();
1644
1645            List<com.liferay.portlet.tags.model.TagsAsset> tagsAssets = null;
1646
1647            if ((listeners.length > 0) || (tagsAssetListeners.length > 0)) {
1648                tagsAssets = getTagsAssets(entryId);
1649
1650                for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1651                    for (ModelListener<TagsEntry> listener : listeners) {
1652                        listener.onBeforeRemoveAssociation(entryId,
1653                            com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1654                            tagsAsset.getPrimaryKey());
1655                    }
1656
1657                    for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1658                        listener.onBeforeRemoveAssociation(tagsAsset.getPrimaryKey(),
1659                            TagsEntry.class.getName(), entryId);
1660                    }
1661                }
1662            }
1663
1664            _sqlUpdate.update(new Object[] { new Long(entryId) });
1665
1666            if ((listeners.length > 0) || (tagsAssetListeners.length > 0)) {
1667                for (com.liferay.portlet.tags.model.TagsAsset tagsAsset : tagsAssets) {
1668                    for (ModelListener<TagsEntry> listener : listeners) {
1669                        listener.onAfterRemoveAssociation(entryId,
1670                            com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1671                            tagsAsset.getPrimaryKey());
1672                    }
1673
1674                    for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1675                        listener.onAfterRemoveAssociation(tagsAsset.getPrimaryKey(),
1676                            TagsEntry.class.getName(), entryId);
1677                    }
1678                }
1679            }
1680        }
1681
1682        private SqlUpdate _sqlUpdate;
1683    }
1684
1685    protected class RemoveTagsAsset {
1686        protected RemoveTagsAsset(TagsEntryPersistenceImpl persistenceImpl) {
1687            _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
1688                    "DELETE FROM TagsAssets_TagsEntries WHERE entryId = ? AND assetId = ?",
1689                    new int[] { Types.BIGINT, Types.BIGINT });
1690            _persistenceImpl = persistenceImpl;
1691        }
1692
1693        protected void remove(long entryId, long assetId)
1694            throws SystemException {
1695            if (_persistenceImpl.containsTagsAsset.contains(entryId, assetId)) {
1696                ModelListener<com.liferay.portlet.tags.model.TagsAsset>[] tagsAssetListeners =
1697                    tagsAssetPersistence.getListeners();
1698
1699                for (ModelListener<TagsEntry> listener : listeners) {
1700                    listener.onBeforeRemoveAssociation(entryId,
1701                        com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1702                        assetId);
1703                }
1704
1705                for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1706                    listener.onBeforeRemoveAssociation(assetId,
1707                        TagsEntry.class.getName(), entryId);
1708                }
1709
1710                _sqlUpdate.update(new Object[] {
1711                        new Long(entryId), new Long(assetId)
1712                    });
1713
1714                for (ModelListener<TagsEntry> listener : listeners) {
1715                    listener.onAfterRemoveAssociation(entryId,
1716                        com.liferay.portlet.tags.model.TagsAsset.class.getName(),
1717                        assetId);
1718                }
1719
1720                for (ModelListener<com.liferay.portlet.tags.model.TagsAsset> listener : tagsAssetListeners) {
1721                    listener.onAfterRemoveAssociation(assetId,
1722                        TagsEntry.class.getName(), entryId);
1723                }
1724            }
1725        }
1726
1727        private SqlUpdate _sqlUpdate;
1728        private TagsEntryPersistenceImpl _persistenceImpl;
1729    }
1730
1731    private static final String _SQL_GETTAGSASSETS = "SELECT {TagsAsset.*} FROM TagsAsset INNER JOIN TagsAssets_TagsEntries ON (TagsAssets_TagsEntries.assetId = TagsAsset.assetId) WHERE (TagsAssets_TagsEntries.entryId = ?)";
1732    private static final String _SQL_GETTAGSASSETSSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM TagsAssets_TagsEntries WHERE entryId = ?";
1733    private static final String _SQL_CONTAINSTAGSASSET = "SELECT COUNT(*) AS COUNT_VALUE FROM TagsAssets_TagsEntries WHERE entryId = ? AND assetId = ?";
1734    private static Log _log = LogFactoryUtil.getLog(TagsEntryPersistenceImpl.class);
1735}