001    /**
002     * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence.impl;
016    
017    import com.liferay.portal.kernel.dao.orm.QueryPos;
018    import com.liferay.portal.kernel.dao.orm.QueryUtil;
019    import com.liferay.portal.kernel.dao.orm.SQLQuery;
020    import com.liferay.portal.kernel.dao.orm.Session;
021    import com.liferay.portal.kernel.dao.orm.Type;
022    import com.liferay.portal.kernel.util.StringBundler;
023    import com.liferay.portal.model.NestedSetsTreeNodeModel;
024    
025    import java.util.Iterator;
026    import java.util.List;
027    
028    /**
029     * @author Shuyang Zhou
030     */
031    public class PersistenceNestedSetsTreeManager<T extends NestedSetsTreeNodeModel>
032            extends NestedSetsTreeManager<T> {
033    
034            public PersistenceNestedSetsTreeManager(
035                    BasePersistenceImpl<?> basePersistenceImpl, String tableName,
036                    String entityName, Class<?> entityImplClass, String primaryKeyName,
037                    String nestedSetsTreeNodeScopeIdName, String nestedSetsTreeNodeLeftName,
038                    String nestedSetsTreeNodeRightName) {
039    
040                    _basePersistenceImpl = basePersistenceImpl;
041                    _tableName = tableName;
042                    _entityName = entityName;
043                    _entityImplClass = entityImplClass;
044                    _primaryKeyName = primaryKeyName;
045                    _nestedSetsTreeNodeScopeIdName = nestedSetsTreeNodeScopeIdName;
046                    _nestedSetsTreeNodeLeftName = nestedSetsTreeNodeLeftName;
047                    _nestedSetsTreeNodeRightName = nestedSetsTreeNodeRightName;
048            }
049    
050            @Override
051            protected long doCountAncestors(
052                    long nestedSetsTreeNodeScopeId, long nestedSetsTreeNodeLeft,
053                    long nestedSetsTreeNodeRight) {
054    
055                    Session session = null;
056    
057                    try {
058                            session = _basePersistenceImpl.openSession();
059    
060                            StringBundler sb = new StringBundler(9);
061    
062                            sb.append("SELECT count(*) FROM ");
063                            sb.append(_tableName);
064                            sb.append(" WHERE ");
065                            sb.append(_nestedSetsTreeNodeScopeIdName);
066                            sb.append(" = ? AND ");
067                            sb.append(_nestedSetsTreeNodeLeftName);
068                            sb.append(" <= ? AND ");
069                            sb.append(_nestedSetsTreeNodeRightName);
070                            sb.append(" >= ?");
071    
072                            SQLQuery sqlQuery = session.createSynchronizedSQLQuery(
073                                    sb.toString());
074    
075                            QueryPos qPos = QueryPos.getInstance(sqlQuery);
076    
077                            qPos.add(nestedSetsTreeNodeScopeId);
078                            qPos.add(nestedSetsTreeNodeLeft);
079                            qPos.add(nestedSetsTreeNodeRight);
080    
081                            Number number = (Number)sqlQuery.uniqueResult();
082    
083                            return number.longValue();
084                    }
085                    catch (Exception e) {
086                            throw _basePersistenceImpl.processException(e);
087                    }
088                    finally {
089                            _basePersistenceImpl.closeSession(session);
090                    }
091            }
092    
093            @Override
094            protected long doCountDescendants(
095                    long nestedSetsTreeNodeScopeId, long nestedSetsTreeNodeLeft,
096                    long nestedSetsTreeNodeRight) {
097    
098                    Session session = null;
099    
100                    try {
101                            session =_basePersistenceImpl.openSession();
102    
103                            StringBundler sb = new StringBundler(9);
104    
105                            sb.append("SELECT count(*) FROM ");
106                            sb.append(_tableName);
107                            sb.append(" WHERE ");
108                            sb.append(_nestedSetsTreeNodeScopeIdName);
109                            sb.append(" = ? AND ");
110                            sb.append(_nestedSetsTreeNodeLeftName);
111                            sb.append(" >= ? AND ");
112                            sb.append(_nestedSetsTreeNodeRightName);
113                            sb.append(" <= ?");
114    
115                            SQLQuery sqlQuery = session.createSynchronizedSQLQuery(
116                                    sb.toString());
117    
118                            QueryPos qPos = QueryPos.getInstance(sqlQuery);
119    
120                            qPos.add(nestedSetsTreeNodeScopeId);
121                            qPos.add(nestedSetsTreeNodeLeft);
122                            qPos.add(nestedSetsTreeNodeRight);
123    
124                            Number number = (Number)sqlQuery.uniqueResult();
125    
126                            return number.longValue();
127                    }
128                    catch (Exception e) {
129                            throw _basePersistenceImpl.processException(e);
130                    }
131                    finally {
132                            _basePersistenceImpl.closeSession(session);
133                    }
134            }
135    
136            @Override
137            protected List<T> doGetAncestors(
138                    long nestedSetsTreeNodeScopeId, long nestedSetsTreeNodeLeft,
139                    long nestedSetsTreeNodeRight) {
140    
141                    Session session = null;
142    
143                    try {
144                            session = _basePersistenceImpl.openSession();
145    
146                            StringBundler sb = new StringBundler(11);
147    
148                            sb.append("SELECT {");
149                            sb.append(_entityName);
150                            sb.append(".*} FROM ");
151                            sb.append(_tableName);
152                            sb.append(" WHERE ");
153                            sb.append(_nestedSetsTreeNodeScopeIdName);
154                            sb.append(" = ? AND ");
155                            sb.append(_nestedSetsTreeNodeLeftName);
156                            sb.append(" <= ? AND ");
157                            sb.append(_nestedSetsTreeNodeRightName);
158                            sb.append(" >= ?");
159    
160                            SQLQuery sqlQuery = session.createSynchronizedSQLQuery(
161                                    sb.toString());
162    
163                            sqlQuery.addEntity(_entityName, _entityImplClass);
164    
165                            QueryPos qPos = QueryPos.getInstance(sqlQuery);
166    
167                            qPos.add(nestedSetsTreeNodeScopeId);
168                            qPos.add(nestedSetsTreeNodeLeft);
169                            qPos.add(nestedSetsTreeNodeRight);
170    
171                            return (List<T>)QueryUtil.list(
172                                    sqlQuery, _basePersistenceImpl.getDialect(), QueryUtil.ALL_POS,
173                                    QueryUtil.ALL_POS);
174                    }
175                    catch (Exception e) {
176                            throw _basePersistenceImpl.processException(e);
177                    }
178                    finally {
179                            _basePersistenceImpl.closeSession(session);
180                    }
181            }
182    
183            @Override
184            protected List<T> doGetDescendants(
185                    long nestedSetsTreeNodeScopeId, long nestedSetsTreeNodeLeft,
186                    long nestedSetsTreeNodeRight) {
187    
188                    Session session = null;
189    
190                    try {
191                            session = _basePersistenceImpl.openSession();
192    
193                            StringBundler sb = new StringBundler(11);
194    
195                            sb.append("SELECT {");
196                            sb.append(_entityName);
197                            sb.append(".*} FROM ");
198                            sb.append(_tableName);
199                            sb.append(" WHERE ");
200                            sb.append(_nestedSetsTreeNodeScopeIdName);
201                            sb.append(" = ? AND ");
202                            sb.append(_nestedSetsTreeNodeLeftName);
203                            sb.append(" >= ? AND ");
204                            sb.append(_nestedSetsTreeNodeRightName);
205                            sb.append(" <= ?");
206    
207                            SQLQuery sqlQuery = session.createSynchronizedSQLQuery(
208                                    sb.toString());
209    
210                            sqlQuery.addEntity(_entityName, _entityImplClass);
211    
212                            QueryPos qPos = QueryPos.getInstance(sqlQuery);
213    
214                            qPos.add(nestedSetsTreeNodeScopeId);
215                            qPos.add(nestedSetsTreeNodeLeft);
216                            qPos.add(nestedSetsTreeNodeRight);
217    
218                            return (List<T>)QueryUtil.list(
219                                    sqlQuery, _basePersistenceImpl.getDialect(), QueryUtil.ALL_POS,
220                                    QueryUtil.ALL_POS);
221                    }
222                    catch (Exception e) {
223                            throw _basePersistenceImpl.processException(e);
224                    }
225                    finally {
226                            _basePersistenceImpl.closeSession(session);
227                    }
228            }
229    
230            protected void doUpdate(
231                    boolean leftOrRight, long nestedSetsTreeNodeScopeId, long delta,
232                    long start, boolean startInclusive, long end, boolean endInclusive,
233                    List<T> includeList) {
234    
235                    StringBundler sb = null;
236    
237                    if (includeList == null) {
238                            sb = new StringBundler(14);
239                    }
240                    else {
241                            sb = new StringBundler(17 + includeList.size() * 2);
242                    }
243    
244                    sb.append("UPDATE ");
245                    sb.append(_tableName);
246                    sb.append(" SET ");
247    
248                    if (leftOrRight) {
249                            sb.append(_nestedSetsTreeNodeLeftName);
250                            sb.append(" = (");
251                            sb.append(_nestedSetsTreeNodeLeftName);
252                            sb.append(" + ?)");
253                    }
254                    else {
255                            sb.append(_nestedSetsTreeNodeRightName);
256                            sb.append(" = (");
257                            sb.append(_nestedSetsTreeNodeRightName);
258                            sb.append(" + ?)");
259                    }
260    
261                    sb.append(" WHERE ");
262                    sb.append(_nestedSetsTreeNodeScopeIdName);
263                    sb.append(" = ? AND ");
264    
265                    if (leftOrRight) {
266                            sb.append(_nestedSetsTreeNodeLeftName);
267                    }
268                    else {
269                            sb.append(_nestedSetsTreeNodeRightName);
270                    }
271    
272                    if (startInclusive) {
273                            sb.append(" >= ? AND ");
274                    }
275                    else {
276                            sb.append(" > ? AND ");
277                    }
278    
279                    if (leftOrRight) {
280                            sb.append(_nestedSetsTreeNodeLeftName);
281                    }
282                    else {
283                            sb.append(_nestedSetsTreeNodeRightName);
284                    }
285    
286                    if (endInclusive) {
287                            sb.append(" <= ? ");
288                    }
289                    else {
290                            sb.append(" < ? ");
291                    }
292    
293                    if (includeList != null) {
294                            sb.append(" AND ");
295                            sb.append(_primaryKeyName);
296                            sb.append(" IN(");
297    
298                            for (T t : includeList) {
299                                    sb.append(t.getPrimaryKey());
300                                    sb.append(", ");
301                            }
302    
303                            sb.setIndex(sb.index() - 1);
304    
305                            sb.append(")");
306                    }
307    
308                    Session session = null;
309    
310                    try {
311                            session = _basePersistenceImpl.openSession();
312    
313                            SQLQuery sqlQuery = session.createSynchronizedSQLQuery(
314                                    sb.toString());
315    
316                            QueryPos qPos = QueryPos.getInstance(sqlQuery);
317    
318                            qPos.add(delta);
319                            qPos.add(nestedSetsTreeNodeScopeId);
320                            qPos.add(start);
321                            qPos.add(end);
322    
323                            sqlQuery.executeUpdate();
324                    }
325                    catch (Exception e) {
326                            throw _basePersistenceImpl.processException(e);
327                    }
328                    finally {
329                            _basePersistenceImpl.closeSession(session);
330                    }
331            }
332    
333            @Override
334            protected void doUpdate(
335                    long nestedSetsTreeNodeScopeId, boolean leftOrRight, long delta,
336                    long limit, boolean inclusive) {
337    
338                    StringBundler sb = new StringBundler(12);
339    
340                    sb.append("UPDATE ");
341                    sb.append(_tableName);
342                    sb.append(" SET ");
343    
344                    if (leftOrRight) {
345                            sb.append(_nestedSetsTreeNodeLeftName);
346                            sb.append(" = (");
347                            sb.append(_nestedSetsTreeNodeLeftName);
348                            sb.append(" + ?)");
349                    }
350                    else {
351                            sb.append(_nestedSetsTreeNodeRightName);
352                            sb.append(" = (");
353                            sb.append(_nestedSetsTreeNodeRightName);
354                            sb.append(" + ?)");
355                    }
356    
357                    sb.append(" WHERE ");
358                    sb.append(_nestedSetsTreeNodeScopeIdName);
359                    sb.append(" = ? AND ");
360    
361                    if (leftOrRight) {
362                            sb.append(_nestedSetsTreeNodeLeftName);
363                    }
364                    else {
365                            sb.append(_nestedSetsTreeNodeRightName);
366                    }
367    
368                    if (inclusive) {
369                            sb.append(" >= ?");
370                    }
371                    else {
372                            sb.append(" > ?");
373                    }
374    
375                    Session session = null;
376    
377                    try {
378                            session = _basePersistenceImpl.openSession();
379    
380                            SQLQuery sqlQuery = session.createSynchronizedSQLQuery(
381                                    sb.toString());
382    
383                            QueryPos qPos = QueryPos.getInstance(sqlQuery);
384    
385                            qPos.add(delta);
386                            qPos.add(nestedSetsTreeNodeScopeId);
387                            qPos.add(limit);
388    
389                            sqlQuery.executeUpdate();
390                    }
391                    catch (Exception e) {
392                            throw _basePersistenceImpl.processException(e);
393                    }
394                    finally {
395                            _basePersistenceImpl.closeSession(session);
396                    }
397            }
398    
399            @Override
400            protected void doUpdate(
401                    long nestedSetsTreeNodeScopeId, long delta, long start,
402                    boolean startInclusive, long end, boolean endInclusive,
403                    List<T> includeList) {
404    
405                    doUpdate(
406                            false, nestedSetsTreeNodeScopeId, delta, start, startInclusive, end,
407                            endInclusive, includeList);
408                    doUpdate(
409                            true, nestedSetsTreeNodeScopeId, delta, start, startInclusive, end,
410                            endInclusive, includeList);
411            }
412    
413            @Override
414            protected long getMaxNestedSetsTreeNodeRight(
415                    long nestedSetsTreeNodeScopeId) {
416    
417                    Session session = null;
418    
419                    try {
420                            session = _basePersistenceImpl.openSession();
421    
422                            StringBundler sb = new StringBundler(9);
423    
424                            sb.append("SELECT MAX(");
425                            sb.append(_nestedSetsTreeNodeRightName);
426                            sb.append(") AS maxNestedSetsTreeNodeRight FROM ");
427                            sb.append(_tableName);
428                            sb.append(" WHERE ");
429                            sb.append(_nestedSetsTreeNodeScopeIdName);
430                            sb.append(" = ? AND ");
431                            sb.append(_nestedSetsTreeNodeRightName);
432                            sb.append(" > 0");
433    
434                            SQLQuery sqlQuery = session.createSynchronizedSQLQuery(
435                                    sb.toString());
436    
437                            sqlQuery.addScalar("maxNestedSetsTreeNodeRight", Type.LONG);
438    
439                            QueryPos qPos = QueryPos.getInstance(sqlQuery);
440    
441                            qPos.add(nestedSetsTreeNodeScopeId);
442    
443                            Iterator<Long> iterator = (Iterator<Long>)QueryUtil.iterate(
444                                    sqlQuery, _basePersistenceImpl.getDialect(), QueryUtil.ALL_POS,
445                                    QueryUtil.ALL_POS);
446    
447                            Long maxNSRight = iterator.next();
448    
449                            if (maxNSRight != null) {
450                                    return maxNSRight + 1;
451                            }
452    
453                            return 1;
454                    }
455                    catch (Exception e) {
456                            throw _basePersistenceImpl.processException(e);
457                    }
458                    finally {
459                            _basePersistenceImpl.closeSession(session);
460                    }
461            }
462    
463            private final BasePersistenceImpl<?> _basePersistenceImpl;
464            private final Class<?> _entityImplClass;
465            private final String _entityName;
466            private final String _nestedSetsTreeNodeLeftName;
467            private final String _nestedSetsTreeNodeRightName;
468            private final String _nestedSetsTreeNodeScopeIdName;
469            private final String _primaryKeyName;
470            private final String _tableName;
471    
472    }