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                    }
091                    catch (Exception e) {
092                            throw ExceptionTranslator.translate(e);
093                    }
094            }
095    
096            @Override
097            public SQLQuery createSQLQuery(String queryString) throws ORMException {
098                    return createSQLQuery(queryString, true);
099            }
100    
101            @Override
102            public SQLQuery createSQLQuery(String queryString, boolean strictName)
103                    throws ORMException {
104    
105                    try {
106                            queryString = SQLTransformer.transformFromJpqlToHql(queryString);
107    
108                            return DoPrivilegedUtil.wrapWhenActive(
109                                    new SQLQueryImpl(
110                                            _session.createSQLQuery(queryString), strictName)
111                            );
112                    }
113                    catch (Exception e) {
114                            throw ExceptionTranslator.translate(e);
115                    }
116            }
117    
118            @Override
119            public SQLQuery createSynchronizedSQLQuery(String queryString)
120                    throws ORMException {
121    
122                    return createSynchronizedSQLQuery(queryString, true);
123            }
124    
125            @Override
126            public SQLQuery createSynchronizedSQLQuery(
127                            String queryString, boolean strictName)
128                    throws ORMException {
129    
130                    try {
131                            queryString = SQLTransformer.transformFromJpqlToHql(queryString);
132    
133                            SQLQuery sqlQuery = new SQLQueryImpl(
134                                    _session.createSQLQuery(queryString), strictName);
135    
136                            String[] tableNames = SQLQueryTableNamesUtil.getTableNames(
137                                    queryString);
138    
139                            sqlQuery.addSynchronizedQuerySpaces(tableNames);
140    
141                            return DoPrivilegedUtil.wrapWhenActive(sqlQuery);
142                    }
143                    catch (Exception e) {
144                            throw ExceptionTranslator.translate(e);
145                    }
146            }
147    
148            @NotPrivileged
149            @Override
150            public void delete(Object object) throws ORMException {
151                    try {
152                            _session.delete(object);
153                    }
154                    catch (Exception e) {
155                            throw ExceptionTranslator.translate(e);
156                    }
157            }
158    
159            @NotPrivileged
160            @Override
161            public void evict(Object object) throws ORMException {
162                    try {
163                            _session.evict(object);
164                    }
165                    catch (Exception e) {
166                            throw ExceptionTranslator.translate(e);
167                    }
168            }
169    
170            @NotPrivileged
171            @Override
172            public void flush() throws ORMException {
173                    try {
174                            _session.flush();
175                    }
176                    catch (Exception e) {
177                            throw ExceptionTranslator.translate(e);
178                    }
179            }
180    
181            @NotPrivileged
182            @Override
183            public Object get(Class<?> clazz, Serializable id) throws ORMException {
184                    try {
185                            return _session.get(clazz, id);
186                    }
187                    catch (Exception e) {
188                            throw ExceptionTranslator.translate(e);
189                    }
190            }
191    
192            /**
193             * @deprecated As of 6.1.0
194             */
195            @Deprecated
196            @NotPrivileged
197            @Override
198            public Object get(Class<?> clazz, Serializable id, LockMode lockMode)
199                    throws ORMException {
200    
201                    try {
202                            return _session.get(
203                                    clazz, id, LockModeTranslator.translate(lockMode));
204                    }
205                    catch (Exception e) {
206                            throw ExceptionTranslator.translate(e);
207                    }
208            }
209    
210            @NotPrivileged
211            @Override
212            public Object getWrappedSession() {
213                    return _session;
214            }
215    
216            @NotPrivileged
217            @Override
218            public boolean isDirty() throws ORMException {
219                    try {
220                            return _session.isDirty();
221                    }
222                    catch (Exception e) {
223                            throw ExceptionTranslator.translate(e);
224                    }
225            }
226    
227            @NotPrivileged
228            @Override
229            public Object load(Class<?> clazz, Serializable id) throws ORMException {
230                    try {
231                            return _session.load(clazz, id);
232                    }
233                    catch (Exception e) {
234                            throw ExceptionTranslator.translate(e);
235                    }
236            }
237    
238            @NotPrivileged
239            @Override
240            public Object merge(Object object) throws ORMException {
241                    try {
242                            return _session.merge(object);
243                    }
244                    catch (Exception e) {
245                            throw ExceptionTranslator.translate(e, _session, object);
246                    }
247            }
248    
249            @NotPrivileged
250            @Override
251            public Serializable save(Object object) throws ORMException {
252                    try {
253                            return _session.save(object);
254                    }
255                    catch (Exception e) {
256                            throw ExceptionTranslator.translate(e);
257                    }
258            }
259    
260            @NotPrivileged
261            @Override
262            public void saveOrUpdate(Object object) throws ORMException {
263                    try {
264                            _session.saveOrUpdate(object);
265                    }
266                    catch (Exception e) {
267                            throw ExceptionTranslator.translate(e, _session, object);
268                    }
269            }
270    
271            private final org.hibernate.Session _session;
272    
273    }