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