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.dao.orm.hibernate;
016    
017    import com.liferay.portal.dao.orm.common.SQLTransformer;
018    import com.liferay.portal.kernel.dao.orm.LockMode;
019    import com.liferay.portal.kernel.dao.orm.ORMException;
020    import com.liferay.portal.kernel.dao.orm.Query;
021    import com.liferay.portal.kernel.dao.orm.SQLQuery;
022    import com.liferay.portal.kernel.dao.orm.Session;
023    import com.liferay.portal.kernel.security.pacl.DoPrivileged;
024    import com.liferay.portal.kernel.security.pacl.NotPrivileged;
025    import com.liferay.portal.security.lang.DoPrivilegedUtil;
026    
027    import java.io.Serializable;
028    
029    import java.sql.Connection;
030    
031    /**
032     * @author Brian Wing Shun Chan
033     * @author Shuyang Zhou
034     */
035    @DoPrivileged
036    public class SessionImpl implements Session {
037    
038            public SessionImpl(org.hibernate.Session session) {
039                    _session = session;
040            }
041    
042            @NotPrivileged
043            @Override
044            public void clear() throws ORMException {
045                    try {
046                            _session.clear();
047                    }
048                    catch (Exception e) {
049                            throw ExceptionTranslator.translate(e);
050                    }
051            }
052    
053            @NotPrivileged
054            @Override
055            public Connection close() throws ORMException {
056                    try {
057                            return _session.close();
058                    }
059                    catch (Exception e) {
060                            throw ExceptionTranslator.translate(e);
061                    }
062            }
063    
064            @NotPrivileged
065            @Override
066            public boolean contains(Object object) throws ORMException {
067                    try {
068                            return _session.contains(object);
069                    }
070                    catch (Exception e) {
071                            throw ExceptionTranslator.translate(e);
072                    }
073            }
074    
075            @Override
076            public Query createQuery(String queryString) throws ORMException {
077                    return createQuery(queryString, true);
078            }
079    
080            @Override
081            public Query createQuery(String queryString, boolean strictName)
082                    throws ORMException {
083    
084                    try {
085                            queryString = SQLTransformer.transformFromJpqlToHql(queryString);
086    
087                            return DoPrivilegedUtil.wrapWhenActive(
088                                    new QueryImpl(_session.createQuery(queryString), strictName));
089                    }
090                    catch (Exception e) {
091                            throw ExceptionTranslator.translate(e);
092                    }
093            }
094    
095            @Override
096            public SQLQuery createSQLQuery(String queryString) throws ORMException {
097                    return createSQLQuery(queryString, true);
098            }
099    
100            @Override
101            public SQLQuery createSQLQuery(String queryString, boolean strictName)
102                    throws ORMException {
103    
104                    try {
105                            queryString = SQLTransformer.transformFromJpqlToHql(queryString);
106    
107                            return DoPrivilegedUtil.wrapWhenActive(
108                                    new SQLQueryImpl(
109                                            _session.createSQLQuery(queryString), strictName));
110                    }
111                    catch (Exception e) {
112                            throw ExceptionTranslator.translate(e);
113                    }
114            }
115    
116            @Override
117            public SQLQuery createSynchronizedSQLQuery(String queryString)
118                    throws ORMException {
119    
120                    return createSynchronizedSQLQuery(queryString, true);
121            }
122    
123            @Override
124            public SQLQuery createSynchronizedSQLQuery(
125                            String queryString, boolean strictName)
126                    throws ORMException {
127    
128                    try {
129                            queryString = SQLTransformer.transformFromJpqlToHql(queryString);
130    
131                            SQLQuery sqlQuery = new SQLQueryImpl(
132                                    _session.createSQLQuery(queryString), strictName);
133    
134                            String[] tableNames = SQLQueryTableNamesUtil.getTableNames(
135                                    queryString);
136    
137                            sqlQuery.addSynchronizedQuerySpaces(tableNames);
138    
139                            return DoPrivilegedUtil.wrapWhenActive(sqlQuery);
140                    }
141                    catch (Exception e) {
142                            throw ExceptionTranslator.translate(e);
143                    }
144            }
145    
146            @NotPrivileged
147            @Override
148            public void delete(Object object) throws ORMException {
149                    try {
150                            _session.delete(object);
151                    }
152                    catch (Exception e) {
153                            throw ExceptionTranslator.translate(e);
154                    }
155            }
156    
157            @NotPrivileged
158            @Override
159            public void evict(Object object) throws ORMException {
160                    try {
161                            _session.evict(object);
162                    }
163                    catch (Exception e) {
164                            throw ExceptionTranslator.translate(e);
165                    }
166            }
167    
168            @NotPrivileged
169            @Override
170            public void flush() throws ORMException {
171                    try {
172                            _session.flush();
173                    }
174                    catch (Exception e) {
175                            throw ExceptionTranslator.translate(e);
176                    }
177            }
178    
179            @NotPrivileged
180            @Override
181            public Object get(Class<?> clazz, Serializable id) throws ORMException {
182                    try {
183                            return _session.get(clazz, id);
184                    }
185                    catch (Exception e) {
186                            throw ExceptionTranslator.translate(e);
187                    }
188            }
189    
190            /**
191             * @deprecated As of 6.1.0
192             */
193            @Deprecated
194            @NotPrivileged
195            @Override
196            public Object get(Class<?> clazz, Serializable id, LockMode lockMode)
197                    throws ORMException {
198    
199                    try {
200                            return _session.get(
201                                    clazz, id, LockModeTranslator.translate(lockMode));
202                    }
203                    catch (Exception e) {
204                            throw ExceptionTranslator.translate(e);
205                    }
206            }
207    
208            @NotPrivileged
209            @Override
210            public Object getWrappedSession() {
211                    return _session;
212            }
213    
214            @NotPrivileged
215            @Override
216            public boolean isDirty() throws ORMException {
217                    try {
218                            return _session.isDirty();
219                    }
220                    catch (Exception e) {
221                            throw ExceptionTranslator.translate(e);
222                    }
223            }
224    
225            @NotPrivileged
226            @Override
227            public Object load(Class<?> clazz, Serializable id) throws ORMException {
228                    try {
229                            return _session.load(clazz, id);
230                    }
231                    catch (Exception e) {
232                            throw ExceptionTranslator.translate(e);
233                    }
234            }
235    
236            @NotPrivileged
237            @Override
238            public Object merge(Object object) throws ORMException {
239                    try {
240                            return _session.merge(object);
241                    }
242                    catch (Exception e) {
243                            throw ExceptionTranslator.translate(e, _session, object);
244                    }
245            }
246    
247            @NotPrivileged
248            @Override
249            public Serializable save(Object object) throws ORMException {
250                    try {
251                            return _session.save(object);
252                    }
253                    catch (Exception e) {
254                            throw ExceptionTranslator.translate(e);
255                    }
256            }
257    
258            @NotPrivileged
259            @Override
260            public void saveOrUpdate(Object object) throws ORMException {
261                    try {
262                            _session.saveOrUpdate(object);
263                    }
264                    catch (Exception e) {
265                            throw ExceptionTranslator.translate(e, _session, object);
266                    }
267            }
268    
269            private final org.hibernate.Session _session;
270    
271    }