Facilities/ActiveRecordIntegration/Castle.Facilities.ActiveRecordIntegration/SafeSessionProxy.cs

   1 // Copyright 2004-2007 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Facilities.ActiveRecordIntegration
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Data;
  20
  21         using NHibernate;
  22         using NHibernate.Type;
  23
  24         using Castle.ActiveRecord.Framework;
  25
  26         /// <summary>
  27         /// This class implements <see cref="ISession"/>
  28         /// and delegates <see cref="Close"/> and
  29         /// <see cref="Dispose"/> to <see cref="ISessionFactoryHolder.ReleaseSession"/>
  30         /// as the session is in fact managed by ActiveRecord framework
  31         /// </summary>
  32         public class SafeSessionProxy : ISession, IDisposable
  33         {
  34                 private readonly ISession innerSession;
  35                 private readonly ISessionFactoryHolder holder;
  36
  37                 private bool wasClosed;
  38
  39                 public SafeSessionProxy(ISessionFactoryHolder holder, ISession innerSession)
  40                 {
  41                         if (innerSession == null) throw new ArgumentNullException("innerSession");
  42
  43                         this.innerSession = innerSession;
  44                         this.holder = holder;
  45                 }
  46
  47                 public FlushMode FlushMode
  48                 {
  49                         get { return innerSession.FlushMode; }
  50                         set { innerSession.FlushMode = value; }
  51                 }
  52
  53                 public ISessionFactory SessionFactory
  54                 {
  55                         get { return innerSession.SessionFactory; }
  56                 }
  57
  58                 public IDbConnection Connection
  59                 {
  60                         get { return innerSession.Connection; }
  61                 }
  62
  63                 public bool IsOpen
  64                 {
  65                         get { return innerSession.IsOpen; }
  66                 }
  67
  68                 public bool IsConnected
  69                 {
  70                         get { return innerSession.IsConnected; }
  71                 }
  72
  73                 public ITransaction Transaction
  74                 {
  75                         get { return innerSession.Transaction; }
  76                 }
  77
  78                 public void Flush()
  79                 {
  80                         innerSession.Flush();
  81                 }
  82
  83                 public IDbConnection Disconnect()
  84                 {
  85                         return innerSession.Disconnect();
  86                 }
  87
  88                 public void Reconnect()
  89                 {
  90                         innerSession.Reconnect();
  91                 }
  92
  93                 public void Reconnect(IDbConnection connection)
  94                 {
  95                         innerSession.Reconnect(connection);
  96                 }
  97
  98                 public IDbConnection Close()
  99                 {
 100                         if (!wasClosed)
 101                         {
 102                                 wasClosed = true;
 103                                 holder.ReleaseSession( innerSession );
 104                                 return null;
 105                         }
 106                         else
 107                         {
 108                                 throw new InvalidOperationException("Session was closed");
 109                         }
 110                 }
 111
 112                 public void CancelQuery()
 113                 {
 114                         innerSession.CancelQuery();
 115                 }
 116
 117                 public bool IsDirty()
 118                 {
 119                         return innerSession.IsDirty();
 120                 }
 121
 122                 public object GetIdentifier(object obj)
 123                 {
 124                         return innerSession.GetIdentifier(obj);
 125                 }
 126
 127                 public bool Contains(object obj)
 128                 {
 129                         return innerSession.Contains(obj);
 130                 }
 131
 132                 public void Evict(object obj)
 133                 {
 134                         innerSession.Evict(obj);
 135                 }
 136
 137                 public object Load(Type theType, object id, LockMode lockMode)
 138                 {
 139                         return innerSession.Load(theType, id, lockMode);
 140                 }
 141
 142                 public object Load(Type theType, object id)
 143                 {
 144                         return innerSession.Load(theType, id);
 145                 }
 146
 147                 public T Load<T>(object id, LockMode lockMode)
 148                 {
 149                         return innerSession.Load<T>(id, lockMode);
 150                 }
 151
 152                 public T Load<T>(object id)
 153                 {
 154                         return innerSession.Load<T>(id);
 155                 }
 156
 157                 public void Load(object obj, object id)
 158                 {
 159                         innerSession.Load(obj, id);
 160                 }
 161
 162                 public object Get(Type clazz, object id)
 163                 {
 164                         return innerSession.Get(clazz, id);
 165                 }
 166
 167                 public object Get(Type clazz, object id, LockMode lockMode)
 168                 {
 169                         return innerSession.Get(clazz, id, lockMode);
 170                 }
 171
 172                 public T Get<T>(object id)
 173                 {
 174                         return innerSession.Get<T>(id);
 175                 }
 176
 177                 public T Get<T>(object id, LockMode lockMode)
 178                 {
 179                         return innerSession.Get<T>(id, lockMode);
 180                 }
 181
 182                 public IFilter EnableFilter(string filterName)
 183                 {
 184                         return innerSession.EnableFilter(filterName);
 185                 }
 186
 187                 public IFilter GetEnabledFilter(string filterName)
 188                 {
 189                         return innerSession.GetEnabledFilter(filterName);
 190                 }
 191
 192                 public void DisableFilter(string filterName)
 193                 {
 194                         innerSession.DisableFilter(filterName);
 195                 }
 196
 197                 public IMultiQuery CreateMultiQuery()
 198                 {
 199                         return innerSession.CreateMultiQuery();
 200                 }
 201
 202                 public void Replicate(object obj, ReplicationMode replicationMode)
 203                 {
 204                         innerSession.Replicate(obj, replicationMode);
 205                 }
 206
 207                 public object Save(object obj)
 208                 {
 209                         return innerSession.Save(obj);
 210                 }
 211
 212                 public void Save(object obj, object id)
 213                 {
 214                         innerSession.Save(obj, id);
 215                 }
 216
 217                 public void SaveOrUpdate(object obj)
 218                 {
 219                         innerSession.SaveOrUpdate(obj);
 220                 }
 221
 222                 public void Update(object obj)
 223                 {
 224                         innerSession.Update(obj);
 225                 }
 226
 227                 public void Update(object obj, object id)
 228                 {
 229                         innerSession.Update(obj, id);
 230                 }
 231
 232                 public object SaveOrUpdateCopy(object obj)
 233                 {
 234                         return innerSession.SaveOrUpdateCopy(obj);
 235                 }
 236
 237                 public object SaveOrUpdateCopy(object obj, object id)
 238                 {
 239                         return innerSession.SaveOrUpdateCopy(obj, id);
 240                 }
 241
 242                 public void Delete(object obj)
 243                 {
 244                         innerSession.Delete(obj);
 245                 }
 246
 247                 public IList Find(String query)
 248                 {
 249                         return innerSession.CreateQuery(query).List();
 250                 }
 251
 252                 public IList Find(String query, object value, IType type)
 253                 {
 254                         // TODO: This is deprecated. Use ISession.CreateQuery().SetXYZ().List()
 255                         return innerSession.Find(query, value, type);
 256                 }
 257
 258                 public IList Find(String query, object[] values, IType[] types)
 259                 {
 260                         // TODO: This is deprecated. Use ISession.CreateQuery().SetXYZ().List()
 261                         return innerSession.Find(query, values, types);
 262                 }
 263
 264                 public IEnumerable Enumerable(String query)
 265                 {
 266                         // TODO: This is deprecated. Use ISession.CreateQuery().SetXYZ().List()
 267                         return innerSession.Enumerable(query);
 268                 }
 269
 270                 public IEnumerable Enumerable(String query, object value, IType type)
 271                 {
 272                         // TODO: This is deprecated. Use ISession.CreateQuery().SetXYZ().List()
 273                         return innerSession.Enumerable(query, value, type);
 274                 }
 275
 276                 public IEnumerable Enumerable(String query, object[] values, IType[] types)
 277                 {
 278                         // TODO: This is deprecated. Use ISession.CreateQuery().SetXYZ().List()
 279                         return innerSession.Enumerable(query, values, types);
 280                 }
 281
 282                 public ICollection Filter(object collection, String filter)
 283                 {
 284                         // TODO: This is deprecated. Use ISession.CreateQuery().SetXYZ().List()
 285                         return innerSession.Filter(collection, filter);
 286                 }
 287
 288                 public ICollection Filter(object collection, String filter, object value, IType type)
 289                 {
 290                         // TODO: This is deprecated. Use ISession.CreateQuery().SetXYZ().List()
 291                         return innerSession.Filter(collection, filter, value, type);
 292                 }
 293
 294                 public ICollection Filter(object collection, String filter, object[] values, IType[] types)
 295                 {
 296                         // TODO: This is deprecated. Use ISession.CreateQuery().SetXYZ().List()
 297                         return innerSession.Filter(collection, filter, values, types);
 298                 }
 299
 300                 public int Delete(String query)
 301                 {
 302                         return innerSession.Delete(query);
 303                 }
 304
 305                 public int Delete(String query, object value, IType type)
 306                 {
 307                         return innerSession.Delete(query, value, type);
 308                 }
 309
 310                 public int Delete(String query, object[] values, IType[] types)
 311                 {
 312                         return innerSession.Delete(query, values, types);
 313                 }
 314
 315                 public void Lock(object obj, LockMode lockMode)
 316                 {
 317                         innerSession.Lock(obj, lockMode);
 318                 }
 319
 320                 public void Refresh(object obj)
 321                 {
 322                         innerSession.Refresh(obj);
 323                 }
 324
 325                 public void Refresh(object obj, LockMode lockMode)
 326                 {
 327                         innerSession.Refresh(obj,lockMode);
 328                 }
 329
 330                 public LockMode GetCurrentLockMode(object obj)
 331                 {
 332                         return innerSession.GetCurrentLockMode(obj);
 333                 }
 334
 335                 public ITransaction BeginTransaction()
 336                 {
 337                         return innerSession.BeginTransaction();
 338                 }
 339
 340                 public ITransaction BeginTransaction(IsolationLevel isolationLevel)
 341                 {
 342                         return innerSession.BeginTransaction(isolationLevel);
 343                 }
 344
 345                 public ICriteria CreateCriteria(Type persistentClass)
 346                 {
 347                         return innerSession.CreateCriteria(persistentClass);
 348                 }
 349
 350                 public ICriteria CreateCriteria(Type persistentClass, string alias)
 351                 {
 352                         return innerSession.CreateCriteria(persistentClass, alias);
 353                 }
 354
 355                 public IQuery CreateQuery(String queryString)
 356                 {
 357                         return innerSession.CreateQuery(queryString);
 358                 }
 359
 360                 public IQuery CreateFilter(object collection, String queryString)
 361                 {
 362                         return innerSession.CreateFilter(collection, queryString);
 363                 }
 364
 365                 public IQuery GetNamedQuery(String queryName)
 366                 {
 367                         return innerSession.GetNamedQuery(queryName);
 368                 }
 369
 370                 public ISQLQuery CreateSQLQuery(string queryString)
 371                 {
 372                         return innerSession.CreateSQLQuery(queryString);
 373                 }
 374
 375                 public IQuery CreateSQLQuery(String sql, String returnAlias, Type returnClass)
 376                 {
 377                         return innerSession.CreateSQLQuery(sql, returnAlias, returnClass);
 378                 }
 379
 380                 public IQuery CreateSQLQuery(String sql, String[] returnAliases, Type[] returnClasses)
 381                 {
 382                         return innerSession.CreateSQLQuery(sql, returnAliases, returnClasses);
 383                 }
 384
 385                 public void Clear()
 386                 {
 387                         innerSession.Clear();
 388                 }
 389
 390                 public void Dispose()
 391                 {
 392                         if (!wasClosed)
 393                         {
 394                                 holder.ReleaseSession( innerSession );
 395                         }
 396                         else
 397                         {
 398                                 throw new InvalidOperationException("Session was closed");
 399                         }
 400                 }
 401
 402                 public NHibernate.Engine.ISessionImplementor GetSessionImplementation()
 403                 {
 404                         return innerSession.GetSessionImplementation();
 405                 }
 406         }
 407 }