ActiveRecord/Castle.ActiveRecord/Framework/ActiveRecordBase.cs

   1 // Copyright 2004-2008 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.ActiveRecord
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Generic;
  20         using Castle.ActiveRecord.Framework;
  21         using Castle.ActiveRecord.Framework.Internal;
  22         using Castle.ActiveRecord.Queries;
  23
  24         using NHibernate;
  25         using NHibernate.Criterion;
  26         using Castle.Components.Validator;
  27
  28         /// <summary>
  29         /// Allow custom executions using the NHibernate's ISession.
  30         /// </summary>
  31         public delegate object NHibernateDelegate(ISession session, object instance);
  32
  33         /// <summary>
  34         /// Base class for all ActiveRecord classes. Implements
  35         /// all the functionality to simplify the code on the
  36         /// subclasses.
  37         /// </summary>
  38         [Serializable]
  39         public abstract class ActiveRecordBase : ActiveRecordHooksBase
  40         {
  41                 /// <summary>
  42                 /// The global holder for the session factories.
  43                 /// </summary>
  44                 protected internal static ISessionFactoryHolder holder;
  45
  46                 #region internal static
  47
  48                 internal static void EnsureInitialized(Type type)
  49                 {
  50                         if (holder == null)
  51                         {
  52                                 String message = String.Format("An ActiveRecord class ({0}) was used but the framework seems not " +
  53                                                                                            "properly initialized. Did you forget about ActiveRecordStarter.Initialize() ?",
  54                                                                                            type.FullName);
  55                                 throw new ActiveRecordException(message);
  56                         }
  57                         if (type != typeof(ActiveRecordBase) && GetModel(type) == null)
  58                         {
  59                                 String message = String.Format("You have accessed an ActiveRecord class that wasn't properly initialized. " +
  60                                                                                            "There are two possible explanations: that the call to ActiveRecordStarter.Initialize() didn't include {0} class, or that {0} class is not decorated with the [ActiveRecord] attribute.",
  61                                                                                            type.FullName);
  62                                 throw new ActiveRecordException(message);
  63                         }
  64                 }
  65
  66                 /// <summary>
  67                 /// Internally used
  68                 /// </summary>
  69                 /// <param name="arType">The type.</param>
  70                 /// <param name="model">The model.</param>
  71                 internal static void Register(Type arType, ActiveRecordModel model)
  72                 {
  73                         ActiveRecordModel.Register(arType, model);
  74                 }
  75
  76                 /// <summary>
  77                 /// Internally used
  78                 /// </summary>
  79                 /// <param name="arType">The type.</param>
  80                 /// <returns>An <see cref="ActiveRecordModel"/></returns>
  81                 internal static ActiveRecordModel GetModel(Type arType)
  82                 {
  83                         return ActiveRecordModel.GetModel(arType);
  84                 }
  85
  86                 #endregion
  87
  88                 #region protected internal static
  89
  90                 #region Create/Update/Save/Delete/DeleteAll/Refresh
  91
  92                 #region Create
  93
  94                 /// <summary>
  95                 /// Creates (Saves) a new instance to the database.
  96                 /// </summary>
  97                 /// <param name="instance">The ActiveRecord instance to be created on the database</param>
  98                 protected internal static void Create(object instance)
  99                 {
 100                         InternalCreate(instance, false);
 101                 }
 102
 103                 /// <summary>
 104                 /// Creates (Saves) a new instance to the database and flushes the session.
 105                 /// </summary>
 106                 /// <param name="instance">The ActiveRecord instance to be created on the database</param>
 107                 protected internal static void CreateAndFlush(object instance)
 108                 {
 109                         InternalCreate(instance, true);
 110                 }
 111
 112                 /// <summary>
 113                 /// Creates (Saves) a new instance to the database.
 114                 /// </summary>
 115                 /// <param name="instance">The ActiveRecord instance to be created on the database</param>
 116                 /// <param name="flush">if set to <c>true</c>, the operation will be followed by a session flush.</param>
 117                 private static void InternalCreate(object instance, bool flush)
 118                 {
 119                         if (instance == null) throw new ArgumentNullException("instance");
 120
 121                         EnsureInitialized(instance.GetType());
 122
 123                         ISession session = holder.CreateSession(instance.GetType());
 124
 125                         try
 126                         {
 127                                 session.Save(instance);
 128
 129                                 if (flush)
 130                                 {
 131                                         session.Flush();
 132                                 }
 133                         }
 134                         catch(Exception ex)
 135                         {
 136                                 holder.FailSession(session);
 137
 138                                 // NHibernate catches our ValidationException, and as such it is the innerexception here
 139                                 if (ex is ValidationException)
 140                                         throw ;
 141
 142                                 if (ex.InnerException is ValidationException)
 143                                         throw ex.InnerException;
 144
 145                                 throw new ActiveRecordException("Could not perform Create for " + instance.GetType().Name, ex);
 146
 147                         }
 148                         finally
 149                         {
 150                                 holder.ReleaseSession(session);
 151                         }
 152                 }
 153
 154                 #endregion
 155
 156                 #region Delete
 157
 158                 /// <summary>
 159                 /// Deletes the instance from the database.
 160                 /// </summary>
 161                 /// <param name="instance">The ActiveRecord instance to be deleted</param>
 162                 protected internal static void Delete(object instance)
 163                 {
 164                         InternalDelete(instance, false);
 165                 }
 166
 167                 /// <summary>
 168                 /// Deletes the instance from the database and flushes the session.
 169                 /// </summary>
 170                 /// <param name="instance">The ActiveRecord instance to be deleted</param>
 171                 protected internal static void DeleteAndFlush(object instance)
 172                 {
 173                         InternalDelete(instance, true);
 174                 }
 175
 176                 /// <summary>
 177                 /// Deletes the instance from the database.
 178                 /// </summary>
 179                 /// <param name="instance">The ActiveRecord instance to be deleted</param>
 180                 /// <param name="flush">if set to <c>true</c>, the operation will be followed by a session flush.</param>
 181                 private static void InternalDelete(object instance, bool flush)
 182                 {
 183                         if (instance == null) throw new ArgumentNullException("instance");
 184
 185                         EnsureInitialized(instance.GetType());
 186
 187                         ISession session = holder.CreateSession(instance.GetType());
 188
 189                         try
 190                         {
 191                                 session.Delete(instance);
 192
 193                                 if (flush)
 194                                 {
 195                                         session.Flush();
 196                                 }
 197                         }
 198                         catch (ValidationException)
 199                         {
 200                                 holder.FailSession(session);
 201
 202                                 throw;
 203
 204                         }
 205                         catch (Exception ex)
 206                         {
 207                                 holder.FailSession(session);
 208
 209                                 throw new ActiveRecordException("Could not perform Delete for " + instance.GetType().Name, ex);
 210                         }
 211                         finally
 212                         {
 213                                 holder.ReleaseSession(session);
 214                         }
 215                 }
 216
 217                 #endregion
 218
 219                 #region Replicate
 220
 221                 /// <summary>
 222                 /// From NHibernate documentation:
 223                 /// Persist all reachable transient objects, reusing the current identifier
 224                 /// values. Note that this will not trigger the Interceptor of the Session.
 225                 /// </summary>
 226                 /// <param name="instance">The instance.</param>
 227                 /// <param name="replicationMode">The replication mode.</param>
 228                 protected internal static void Replicate(object instance, ReplicationMode replicationMode)
 229                 {
 230                         if (instance == null)
 231                         {
 232                                 throw new ArgumentNullException("instance");
 233                         }
 234
 235                         EnsureInitialized(instance.GetType());
 236
 237                         ISession session = holder.CreateSession(instance.GetType());
 238
 239                         try
 240                         {
 241                                 session.Replicate(instance, replicationMode);
 242                         }
 243                         catch(Exception ex)
 244                         {
 245                                 holder.FailSession(session);
 246
 247                                 // NHibernate catches our ValidationException, and as such it is the innerexception here
 248                                 if (ex.InnerException is ValidationException)
 249                                 {
 250                                         throw ex.InnerException;
 251                                 }
 252                                 else
 253                                 {
 254                                         throw new ActiveRecordException("Could not perform Replicate for " + instance.GetType().Name, ex);
 255                                 }
 256                         }
 257                         finally
 258                         {
 259                                 holder.ReleaseSession(session);
 260                         }
 261                 }
 262
 263                 #endregion
 264
 265                 #region Refresh
 266
 267                 /// <summary>
 268                 /// Refresh the instance from the database.
 269                 /// </summary>
 270                 /// <param name="instance">The ActiveRecord instance to be reloaded</param>
 271                 protected internal static void Refresh(object instance)
 272                 {
 273                         if (instance == null) throw new ArgumentNullException("instance");
 274
 275                         EnsureInitialized(instance.GetType());
 276
 277                         ISession session = holder.CreateSession(instance.GetType());
 278
 279                         try
 280                         {
 281                                 session.Refresh(instance);
 282                         }
 283                         catch (Exception ex)
 284                         {
 285                                 holder.FailSession(session);
 286
 287                                 // NHibernate catches our ValidationException, and as such it is the innerexception here
 288                                 if (ex.InnerException is ValidationException)
 289                                 {
 290                                         throw ex.InnerException;
 291                                 }
 292                                 else
 293                                 {
 294                                         throw new ActiveRecordException("Could not perform Refresh for " + instance.GetType().Name, ex);
 295                                 }
 296                         }
 297                         finally
 298                         {
 299                                 holder.ReleaseSession(session);
 300                         }
 301                 }
 302
 303                 #endregion
 304
 305                 #region DeleteAll
 306
 307                 /// <summary>
 308                 /// Deletes all rows for the specified ActiveRecord type
 309                 /// </summary>
 310                 /// <remarks>
 311                 /// This method is usually useful for test cases.
 312                 /// </remarks>
 313                 /// <param name="type">ActiveRecord type on which the rows on the database should be deleted</param>
 314                 protected internal static void DeleteAll(Type type)
 315                 {
 316                         EnsureInitialized(type);
 317
 318                         ISession session = holder.CreateSession(type);
 319
 320                         try
 321                         {
 322                                 session.Delete(String.Format("from {0}", type.Name));
 323
 324                                 session.Flush();
 325                         }
 326                         catch (ValidationException)
 327                         {
 328                                 holder.FailSession(session);
 329
 330                                 throw;
 331                         }
 332                         catch (Exception ex)
 333                         {
 334                                 holder.FailSession(session);
 335
 336                                 throw new ActiveRecordException("Could not perform DeleteAll for " + type.Name, ex);
 337                         }
 338                         finally
 339                         {
 340                                 holder.ReleaseSession(session);
 341                         }
 342                 }
 343
 344                 /// <summary>
 345                 /// Deletes all rows for the specified ActiveRecord type that matches
 346                 /// the supplied HQL condition
 347                 /// </summary>
 348                 /// <remarks>
 349                 /// This method is usually useful for test cases.
 350                 /// </remarks>
 351                 /// <param name="type">ActiveRecord type on which the rows on the database should be deleted</param>
 352                 /// <param name="where">HQL condition to select the rows to be deleted</param>
 353                 protected internal static void DeleteAll(Type type, String where)
 354                 {
 355                         EnsureInitialized(type);
 356
 357                         ISession session = holder.CreateSession(type);
 358
 359                         try
 360                         {
 361                                 session.Delete(String.Format("from {0} where {1}", type.Name, where));
 362
 363                                 session.Flush();
 364                         }
 365                         catch (ValidationException)
 366                         {
 367                                 holder.FailSession(session);
 368
 369                                 throw;
 370                         }
 371                         catch (Exception ex)
 372                         {
 373                                 holder.FailSession(session);
 374
 375                                 throw new ActiveRecordException("Could not perform DeleteAll for " + type.Name, ex);
 376                         }
 377                         finally
 378                         {
 379                                 holder.ReleaseSession(session);
 380                         }
 381                 }
 382
 383                 /// <summary>
 384                 /// Deletes all <paramref name="targetType" /> objects, based on the primary keys
 385                 /// supplied on <paramref name="pkValues" />.
 386                 /// </summary>
 387                 /// <param name="targetType">The target ActiveRecord type</param>
 388                 /// <param name="pkValues">A list of primary keys</param>
 389                 /// <returns>The number of objects deleted</returns>
 390                 protected internal static int DeleteAll(Type targetType, IEnumerable pkValues)
 391                 {
 392                         if (pkValues == null)
 393                         {
 394                                 return 0;
 395                         }
 396
 397                         int counter = 0;
 398
 399                         foreach (object pk in pkValues)
 400                         {
 401                                 Object obj = FindByPrimaryKey(targetType, pk, false);
 402
 403                                 if (obj != null)
 404                                 {
 405                                         ActiveRecordBase arBase = obj as ActiveRecordBase;
 406
 407                                         if (arBase != null)
 408                                         {
 409                                                 arBase.Delete(); // in order to allow override of the virtual "Delete()" method
 410                                         }
 411                                         else
 412                                         {
 413                                                 Delete(obj);
 414                                         }
 415
 416                                         counter++;
 417                                 }
 418                         }
 419
 420                         return counter;
 421                 }
 422
 423                 #endregion
 424
 425                 #region Update
 426
 427                 /// <summary>
 428                 /// Persists the modification on the instance
 429                 /// state to the database.
 430                 /// </summary>
 431                 /// <param name="instance">The ActiveRecord instance to be updated on the database</param>
 432                 protected internal static void Update(object instance)
 433                 {
 434                         InternalUpdate(instance, false);
 435                 }
 436
 437                 /// <summary>
 438                 /// Persists the modification on the instance
 439                 /// state to the database and flushes the session.
 440                 /// </summary>
 441                 /// <param name="instance">The ActiveRecord instance to be updated on the database</param>
 442                 protected internal static void UpdateAndFlush(object instance)
 443                 {
 444                         InternalUpdate(instance, true);
 445                 }
 446
 447                 /// <summary>
 448                 /// Persists the modification on the instance
 449                 /// state to the database.
 450                 /// </summary>
 451                 /// <param name="instance">The ActiveRecord instance to be updated on the database</param>
 452                 /// <param name="flush">if set to <c>true</c>, the operation will be followed by a session flush.</param>
 453                 private static void InternalUpdate(object instance, bool flush)
 454                 {
 455                         if (instance == null) throw new ArgumentNullException("instance");
 456
 457                         EnsureInitialized(instance.GetType());
 458
 459                         ISession session = holder.CreateSession(instance.GetType());
 460
 461                         try
 462                         {
 463                                 session.Update(instance);
 464
 465                                 if (flush)
 466                                 {
 467                                         session.Flush();
 468                                 }
 469                         }
 470                         catch (ValidationException)
 471                         {
 472                                 holder.FailSession(session);
 473
 474                                 throw;
 475                         }
 476                         catch (Exception ex)
 477                         {
 478                                 holder.FailSession(session);
 479
 480                                 throw new ActiveRecordException("Could not perform Update for " + instance.GetType().Name, ex);
 481                         }
 482                         finally
 483                         {
 484                                 holder.ReleaseSession(session);
 485                         }
 486                 }
 487
 488                 #endregion
 489
 490                 #region Save
 491
 492                 /// <summary>
 493                 /// Saves the instance to the database. If the primary key is unitialized
 494                 /// it creates the instance on the database. Otherwise it updates it.
 495                 /// <para>
 496                 /// If the primary key is assigned, then you must invoke <see cref="Create()"/>
 497                 /// or <see cref="Update()"/> instead.
 498                 /// </para>
 499                 /// </summary>
 500                 /// <param name="instance">The ActiveRecord instance to be saved</param>
 501                 protected internal static void Save(object instance)
 502                 {
 503                         InternalSave(instance, false);
 504                 }
 505
 506                 /// <summary>
 507                 /// Saves the instance to the database and flushes the session. If the primary key is unitialized
 508                 /// it creates the instance on the database. Otherwise it updates it.
 509                 /// <para>
 510                 /// If the primary key is assigned, then you must invoke <see cref="Create()"/>
 511                 /// or <see cref="Update()"/> instead.
 512                 /// </para>
 513                 /// </summary>
 514                 /// <param name="instance">The ActiveRecord instance to be saved</param>
 515                 protected internal static void SaveAndFlush(object instance)
 516                 {
 517                         InternalSave(instance, true);
 518                 }
 519
 520         /// <summary>
 521         /// Saves a copy of the instance to the database. If the primary key is unitialized
 522         /// it creates the instance on the database. Otherwise it updates it.
 523         /// <para>
 524         /// If the primary key is assigned, then you must invoke <see cref="Create()"/>
 525         /// or <see cref="Update()"/> instead.
 526         /// </para>
 527         /// </summary>
 528         /// <param name="instance">The transient instance to be saved</param>
 529         /// <returns>The saved ActiveRecord instance</returns>
 530         protected internal static object SaveCopy(object instance)
 531         {
 532             return InternalSaveCopy(instance, false);
 533         }
 534
 535         /// <summary>
 536         /// Saves a copy of the instance to the database and flushes the session. If the primary key is unitialized
 537         /// it creates the instance on the database. Otherwise it updates it.
 538         /// <para>
 539         /// If the primary key is assigned, then you must invoke <see cref="Create()"/>
 540         /// or <see cref="Update()"/> instead.
 541         /// </para>
 542         /// </summary>
 543         /// <param name="instance">The transient instance to be saved</param>
 544         /// <returns>The saved ActiveRecord instance</returns>
 545         protected internal static object SaveCopyAndFlush(object instance)
 546         {
 547             return InternalSaveCopy(instance, true);
 548         }
 549
 550                 /// <summary>
 551                 /// Saves the instance to the database. If the primary key is unitialized
 552                 /// it creates the instance on the database. Otherwise it updates it.
 553                 /// <para>
 554                 /// If the primary key is assigned, then you must invoke <see cref="Create()"/>
 555                 /// or <see cref="Update()"/> instead.
 556                 /// </para>
 557                 /// </summary>
 558                 /// <param name="instance">The ActiveRecord instance to be saved</param>
 559                 /// <param name="flush">if set to <c>true</c>, the operation will be followed by a session flush.</param>
 560                 private static void InternalSave(object instance, bool flush)
 561                 {
 562                         if (instance == null) throw new ArgumentNullException("instance");
 563
 564                         EnsureInitialized(instance.GetType());
 565
 566                         ISession session = holder.CreateSession(instance.GetType());
 567
 568                         try
 569                         {
 570                                 session.SaveOrUpdate(instance);
 571
 572                                 if (flush)
 573                                 {
 574                                         session.Flush();
 575                                 }
 576                         }
 577                         catch (ValidationException)
 578                         {
 579                                 holder.FailSession(session);
 580
 581                                 throw;
 582                         }
 583                         catch(Exception ex)
 584                         {
 585                                 holder.FailSession(session);
 586
 587                                 // NHibernate catches our ValidationException on Create so it could be the innerexception here
 588                                 if (ex.InnerException is ValidationException)
 589                                 {
 590                                         throw ex.InnerException;
 591                                 }
 592                                 else
 593                                 {
 594                                         throw new ActiveRecordException("Could not perform Save for " + instance.GetType().Name, ex);
 595                                 }
 596                         }
 597                         finally
 598                         {
 599                                 holder.ReleaseSession(session);
 600                         }
 601                 }
 602
 603         /// <summary>
 604         /// Saves a copy of the instance to the database. If the primary key is unitialized
 605         /// it creates the instance on the database. Otherwise it updates it.
 606         /// <para>
 607         /// If the primary key is assigned, then you must invoke <see cref="Create()"/>
 608         /// or <see cref="Update()"/> instead.
 609         /// </para>
 610         /// </summary>
 611         /// <param name="instance">The transient instance to be saved</param>
 612         /// <param name="flush">if set to <c>true</c>, the operation will be followed by a session flush.</param>
 613         /// <returns>The saved ActiveRecord instance.</returns>
 614         private static object InternalSaveCopy(object instance, bool flush)
 615         {
 616             if (instance == null) throw new ArgumentNullException("instance");
 617
 618             EnsureInitialized(instance.GetType());
 619
 620             ISession session = holder.CreateSession(instance.GetType());
 621
 622             try
 623             {
 624                 object persistent = session.SaveOrUpdateCopy(instance);
 625
 626                 if (flush)
 627                 {
 628                     session.Flush();
 629                 }
 630
 631                 return persistent;
 632             }
 633             catch (ValidationException)
 634             {
 635                 holder.FailSession(session);
 636
 637                 throw;
 638             }
 639             catch (Exception ex)
 640             {
 641                 holder.FailSession(session);
 642
 643                 // NHibernate catches our ValidationException on Create so it could be the innerexception here
 644                 if (ex.InnerException is ValidationException)
 645                 {
 646                     throw ex.InnerException;
 647                 }
 648                 else
 649                 {
 650                     throw new ActiveRecordException("Could not perform SaveCopy for " + instance.GetType().Name, ex);
 651                 }
 652             }
 653             finally
 654             {
 655                 holder.ReleaseSession(session);
 656             }
 657         }
 658
 659                 #endregion
 660
 661                 #endregion
 662
 663                 #region Execute
 664
 665                 /// <summary>
 666                 /// Invokes the specified delegate passing a valid
 667                 /// NHibernate session. Used for custom NHibernate queries.
 668                 /// </summary>
 669                 /// <param name="targetType">The target ActiveRecordType</param>
 670                 /// <param name="call">The delegate instance</param>
 671                 /// <param name="instance">The ActiveRecord instance</param>
 672                 /// <returns>Whatever is returned by the delegate invocation</returns>
 673                 protected internal static object Execute(Type targetType, NHibernateDelegate call, object instance)
 674                 {
 675                         if (targetType == null) throw new ArgumentNullException("targetType", "Target type must be informed");
 676                         if (call == null) throw new ArgumentNullException("call", "Delegate must be passed");
 677
 678                         EnsureInitialized(targetType);
 679
 680                         ISession session = holder.CreateSession(targetType);
 681
 682                         try
 683                         {
 684                                 return call(session, instance);
 685                         }
 686                         catch (ValidationException)
 687                         {
 688                                 holder.FailSession(session);
 689
 690                                 throw;
 691                         }
 692                         catch (Exception ex)
 693                         {
 694                                 holder.FailSession(session);
 695
 696                                 throw new ActiveRecordException("Error performing Execute for " + targetType.Name, ex);
 697                         }
 698                         finally
 699                         {
 700                                 holder.ReleaseSession(session);
 701                         }
 702                 }
 703
 704                 #endregion
 705
 706                 #region ExecuteQuery
 707
 708                 /// <summary>
 709                 /// Enumerates the query
 710                 /// Note: only use if you expect most of the values to exist on the second level cache.
 711                 /// </summary>
 712                 /// <param name="query">The query.</param>
 713                 /// <returns>An <see cref="IEnumerable"/></returns>
 714                 protected internal static IEnumerable EnumerateQuery(IActiveRecordQuery query)
 715                 {
 716                         Type rootType = query.RootType;
 717
 718                         EnsureInitialized(rootType);
 719
 720                         ISession session = holder.CreateSession(rootType);
 721
 722                         try
 723                         {
 724                                 return query.Enumerate(session);
 725                         }
 726                         catch (Exception ex)
 727                         {
 728                                 holder.FailSession(session);
 729
 730                                 throw new ActiveRecordException("Could not perform EnumerateQuery for " + rootType.Name, ex);
 731                         }
 732                         finally
 733                         {
 734                                 holder.ReleaseSession(session);
 735                         }
 736                 }
 737
 738                 #endregion
 739
 740                 #region ExecuteQuery
 741
 742                 /// <summary>
 743                 /// Executes the query.
 744                 /// </summary>
 745                 /// <param name="query">The query.</param>
 746                 /// <returns>The query result.</returns>
 747                 public static object ExecuteQuery(IActiveRecordQuery query)
 748                 {
 749                         Type rootType = query.RootType;
 750
 751                         EnsureInitialized(rootType);
 752
 753                         ISession session = holder.CreateSession(rootType);
 754
 755                         try
 756                         {
 757                                 return query.Execute(session);
 758                         }
 759                         catch (Exception ex)
 760                         {
 761                                 holder.FailSession(session);
 762
 763                                 throw new ActiveRecordException("Could not perform ExecuteQuery for " + rootType.Name, ex);
 764                         }
 765                         finally
 766                         {
 767                                 holder.ReleaseSession(session);
 768                         }
 769                 }
 770
 771                 #endregion
 772
 773                 #region Count
 774
 775                 /// <summary>
 776                 /// Returns the number of records of the specified
 777                 /// type in the database
 778                 /// </summary>
 779                 /// <example>
 780                 /// <code>
 781                 /// [ActiveRecord]
 782                 /// public class User : ActiveRecordBase
 783                 /// {
 784                 ///   ...
 785                 ///
 786                 ///   public static int CountAllUsers()
 787                 ///   {
 788                 ///     return Count(typeof(User));
 789                 ///   }
 790                 /// }
 791                 /// </code>
 792                 /// </example>
 793                 /// <param name="targetType">The target type.</param>
 794                 /// <returns>The count result</returns>
 795                 protected internal static int Count(Type targetType)
 796                 {
 797                         CountQuery query = new CountQuery(targetType);
 798
 799                         return (int)ExecuteQuery(query);
 800                 }
 801
 802                 /// <summary>
 803                 /// Returns the number of records of the specified
 804                 /// type in the database
 805                 /// </summary>
 806                 /// <example>
 807                 /// <code>
 808                 /// [ActiveRecord]
 809                 /// public class User : ActiveRecordBase
 810                 /// {
 811                 ///   ...
 812                 ///
 813                 ///   public static int CountAllUsersLocked()
 814                 ///   {
 815                 ///     return Count(typeof(User), "IsLocked = ?", true);
 816                 ///   }
 817                 /// }
 818                 /// </code>
 819                 /// </example>
 820                 /// <param name="targetType">The target type.</param>
 821                 /// <param name="filter">A sql where string i.e. Person=? and DOB &gt; ?</param>
 822                 /// <param name="args">Positional parameters for the filter string</param>
 823                 /// <returns>The count result</returns>
 824                 protected internal static int Count(Type targetType, string filter, params object[] args)
 825                 {
 826                         CountQuery query = new CountQuery(targetType, filter, args);
 827
 828                         return (int)ExecuteQuery(query);
 829                 }
 830
 831                 /// <summary>
 832                 /// Returns the number of records of the specified
 833                 /// type in the database
 834                 /// </summary>
 835                 /// <param name="targetType">The target type.</param>
 836                 /// <param name="criteria">The criteria expression</param>
 837                 /// <returns>The count result</returns>
 838                 protected internal static int Count(Type targetType, ICriterion[] criteria)
 839                 {
 840                         CountQuery query = new CountQuery(targetType, criteria);
 841
 842                         return (int) ExecuteQuery(query);
 843                 }
 844
 845                 /// <summary>
 846                 /// Returns the number of records of the specified
 847                 /// type in the database
 848                 /// </summary>
 849                 /// <param name="targetType">The target type.</param>
 850                 /// <param name="detachedCriteria">The criteria expression</param>
 851                 /// <returns>The count result</returns>
 852                 protected internal static int Count(Type targetType, DetachedCriteria detachedCriteria)
 853                 {
 854                         CountQuery query = new CountQuery(targetType, detachedCriteria);
 855
 856                         return (int)ExecuteQuery(query);
 857                 }
 858
 859                 #endregion
 860
 861                 #region Exists
 862
 863                 /// <summary>
 864                 /// Check if there is any records in the db for the target type
 865                 /// </summary>
 866                 /// <param name="targetType">The target type.</param>
 867                 /// <returns><c>true</c> if there's at least one row</returns>
 868                 protected internal static bool Exists(Type targetType)
 869                 {
 870                         return Count(targetType) > 0;
 871                 }
 872
 873                 /// <summary>
 874                 /// Check if there is any records in the db for the target type
 875                 /// </summary>
 876                 /// <param name="targetType">The target type.</param>
 877                 /// <param name="filter">A sql where string i.e. Person=? and DOB &gt; ?</param>
 878                 /// <param name="args">Positional parameters for the filter string</param>
 879                 /// <returns><c>true</c> if there's at least one row</returns>
 880                 protected internal static bool Exists(Type targetType, string filter, params object[] args)
 881                 {
 882                         return Count(targetType, filter, args) > 0;
 883                 }
 884
 885                 /// <summary>
 886                 /// Check if the <paramref name="id"/> exists in the database.
 887                 /// </summary>
 888                 /// <param name="targetType">The target type.</param>
 889                 /// <param name="id">The id to check on</param>
 890                 /// <returns><c>true</c> if the ID exists; otherwise <c>false</c>.</returns>
 891                 protected internal static bool Exists(Type targetType, object id)
 892                 {
 893                         EnsureInitialized(targetType);
 894                         ISession session = holder.CreateSession(targetType);
 895
 896                         try
 897                         {
 898                                 return session.Get(targetType, id) != null;
 899                         }
 900                         catch(Exception ex)
 901                         {
 902                                 throw new ActiveRecordException("Could not perform Exists for " + targetType.Name + ". Id: " + id, ex);
 903                         }
 904                         finally
 905                         {
 906                                 holder.ReleaseSession(session);
 907                         }
 908                 }
 909
 910                 /// <summary>
 911                 /// Check if any instance matching the criteria exists in the database.
 912                 /// </summary>
 913                 /// <param name="targetType">The target type.</param>
 914                 /// <param name="criteria">The criteria expression</param>
 915                 /// <returns><c>true</c> if an instance is found; otherwise <c>false</c>.</returns>
 916                 protected internal static bool Exists(Type targetType, params ICriterion[] criteria)
 917                 {
 918                         return Count(targetType, criteria) > 0;
 919                 }
 920
 921                 /// <summary>
 922                 /// Check if any instance matching the criteria exists in the database.
 923                 /// </summary>
 924                 /// <param name="targetType">The target type.</param>
 925                 /// <param name="detachedCriteria">The criteria expression</param>
 926                 /// <returns><c>true</c> if an instance is found; otherwise <c>false</c>.</returns>
 927                 protected internal static bool Exists(Type targetType, DetachedCriteria detachedCriteria)
 928                 {
 929                         return Count(targetType, detachedCriteria) > 0;
 930                 }
 931
 932                 #endregion
 933
 934                 #region FindAll
 935
 936                 /// <summary>
 937                 /// Returns all instances found for the specified type according to the criteria
 938                 /// </summary>
 939                 /// <param name="targetType">The target type.</param>
 940                 /// <param name="detachedCriteria">The criteria.</param>
 941                 /// <param name="orders">An <see cref="Array"/> of <see cref="Order"/> objects.</param>
 942                 /// <returns>The <see cref="Array"/> of results.</returns>
 943                 protected internal static Array FindAll(Type targetType, DetachedCriteria detachedCriteria, params Order[] orders)
 944                 {
 945                         EnsureInitialized(targetType);
 946
 947                         ISession session = holder.CreateSession(targetType);
 948
 949                         try
 950                         {
 951                                 ICriteria criteria = detachedCriteria.GetExecutableCriteria(session);
 952
 953                                 AddOrdersToCriteria(criteria, orders);
 954
 955                                 return SupportingUtils.BuildArray(targetType, criteria.List());
 956                         }
 957                         catch(ValidationException)
 958                         {
 959                                 holder.FailSession(session);
 960
 961                                 throw;
 962                         }
 963                         catch(Exception ex)
 964                         {
 965                                 holder.FailSession(session);
 966
 967                                 throw new ActiveRecordException("Could not perform FindAll for " + targetType.Name, ex);
 968                         }
 969                         finally
 970                         {
 971                                 holder.ReleaseSession(session);
 972                         }
 973                 }
 974
 975                 /// <summary>
 976                 /// Returns all instances found for the specified type.
 977                 /// </summary>
 978                 /// <param name="targetType">The target type.</param>
 979                 /// <returns>The <see cref="Array"/> of results</returns>
 980                 protected internal static Array FindAll(Type targetType)
 981                 {
 982                         return FindAll(targetType, (Order[])null);
 983                 }
 984
 985                 /// <summary>
 986                 /// Returns all instances found for the specified type
 987                 /// using sort orders and criteria.
 988                 /// </summary>
 989                 /// <param name="targetType">The The target type.</param>
 990                 /// <param name="orders">An <see cref="Array"/> of <see cref="Order"/> objects.</param>
 991                 /// <param name="criteria">The criteria expression</param>
 992                 /// <returns>The <see cref="Array"/> of results.</returns>
 993                 protected internal static Array FindAll(Type targetType, Order[] orders, params ICriterion[] criteria)
 994                 {
 995                         EnsureInitialized(targetType);
 996
 997                         ISession session = holder.CreateSession(targetType);
 998
 999                         try
1000                         {
1001                                 ICriteria sessionCriteria = session.CreateCriteria(targetType);
1002
1003                                 foreach(ICriterion cond in criteria)
1004                                 {
1005                                         sessionCriteria.Add(cond);
1006                                 }
1007
1008                                 AddOrdersToCriteria(sessionCriteria, orders);
1009
1010                                 return SupportingUtils.BuildArray(targetType, sessionCriteria.List());
1011                         }
1012                         catch (ValidationException)
1013                         {
1014                                 holder.FailSession(session);
1015
1016                                 throw;
1017                         }
1018                         catch (Exception ex)
1019                         {
1020                                 holder.FailSession(session);
1021
1022                                 throw new ActiveRecordException("Could not perform FindAll for " + targetType.Name, ex);
1023                         }
1024                         finally
1025                         {
1026                                 holder.ReleaseSession(session);
1027                         }
1028                 }
1029
1030                 private static void AddOrdersToCriteria(ICriteria criteria, IEnumerable<Order> orders)
1031                 {
1032                         if (orders != null)
1033                         {
1034                                 foreach (Order order in orders)
1035                                 {
1036                                         criteria.AddOrder(order);
1037                                 }
1038                         }
1039                 }
1040
1041                 /// <summary>
1042                 /// Returns all instances found for the specified type
1043                 /// using criteria.
1044                 /// </summary>
1045                 /// <param name="targetType">The target type.</param>
1046                 /// <param name="criteria">The criteria expression</param>
1047                 /// <returns>The <see cref="Array"/> of results.</returns>
1048                 protected internal static Array FindAll(Type targetType, params ICriterion[] criteria)
1049                 {
1050                         return FindAll(targetType, null, criteria);
1051                 }
1052
1053                 #endregion
1054
1055                 #region FindAllByProperty
1056
1057                 /// <summary>
1058                 /// Finds records based on a property value - automatically converts null values to IS NULL style queries.
1059                 /// </summary>
1060                 /// <param name="targetType">The target type</param>
1061                 /// <param name="property">A property name (not a column name)</param>
1062                 /// <param name="value">The value to be equals to</param>
1063                 /// <returns>The <see cref="Array"/> of results.</returns>
1064                 protected internal static Array FindAllByProperty(Type targetType, String property, object value)
1065                 {
1066                         ICriterion criteria = (value == null) ? Expression.IsNull(property) : Expression.Eq(property, value);
1067                         return FindAll(targetType, criteria);
1068                 }
1069
1070                 /// <summary>
1071                 /// Finds records based on a property value - automatically converts null values to IS NULL style queries.
1072                 /// </summary>
1073                 /// <param name="targetType">The target type</param>
1074                 /// <param name="orderByColumn">The column name to be ordered ASC</param>
1075                 /// <param name="property">A property name (not a column name)</param>
1076                 /// <param name="value">The value to be equals to</param>
1077                 /// <returns>The <see cref="Array"/> of results.</returns>
1078                 protected internal static Array FindAllByProperty(Type targetType, String orderByColumn, String property, object value)
1079                 {
1080                         ICriterion criteria = (value == null) ? Expression.IsNull(property) : Expression.Eq(property, value);
1081                         return FindAll(targetType, new Order[] {Order.Asc(orderByColumn)}, criteria);
1082                 }
1083
1084                 #endregion
1085
1086                 #region FindByPrimaryKey
1087
1088                 /// <summary>
1089                 /// Finds an object instance by an unique ID
1090                 /// </summary>
1091                 /// <param name="targetType">The AR subclass type</param>
1092                 /// <param name="id">ID value</param>
1093                 /// <returns>The object instance.</returns>
1094                 protected internal static object FindByPrimaryKey(Type targetType, object id)
1095                 {
1096                         return FindByPrimaryKey(targetType, id, true);
1097                 }
1098
1099                 /// <summary>
1100                 /// Finds an object instance by an unique ID
1101                 /// </summary>
1102                 /// <param name="targetType">The AR subclass type</param>
1103                 /// <param name="id">ID value</param>
1104                 /// <param name="throwOnNotFound"><c>true</c> if you want to catch an exception
1105                 /// if the object is not found</param>
1106                 /// <returns>The object instance.</returns>
1107                 /// <exception cref="ObjectNotFoundException">if <c>throwOnNotFound</c> is set to
1108                 /// <c>true</c> and the row is not found</exception>
1109                 protected internal static object FindByPrimaryKey(Type targetType, object id, bool throwOnNotFound)
1110                 {
1111                         EnsureInitialized(targetType);
1112                         bool hasScope = holder.ThreadScopeInfo.HasInitializedScope;
1113                         ISession session = holder.CreateSession(targetType);
1114
1115                         try
1116                         {
1117                                 object loaded;
1118                                 // Load() and Get() has different semantics with regard to the way they
1119                                 // handle null values, Get() _must_ check that the value exists, Load() is allowed
1120                                 // to return an uninitialized proxy that will throw when you access it later.
1121                                 // in order to play well with proxies, we need to use this approach.
1122                                 if (throwOnNotFound)
1123                                 {
1124                                         loaded = session.Load(targetType, id);
1125                                 }
1126                                 else
1127                                 {
1128                                         loaded = session.Get(targetType, id);
1129                                 }
1130                                 //If we are not in a scope, we want to initialize the entity eagerly, since other wise the
1131                                 //user will get an exception when it access the entity's property, and it will try to lazy load itself and find that
1132                                 //it has no session.
1133                                 //If we are in a scope, it is the user responsability to keep the scope alive if he wants to use
1134                                 if (!hasScope)
1135                                 {
1136                                         NHibernateUtil.Initialize(loaded);
1137                                 }
1138                                 return loaded;
1139                         }
1140                         catch (ObjectNotFoundException ex)
1141                         {
1142                                 holder.FailSession(session);
1143
1144                                 String message = String.Format("Could not find {0} with id {1}", targetType.Name, id);
1145                                 throw new NotFoundException(message, ex);
1146                         }
1147                         catch (ValidationException)
1148                         {
1149                                 holder.FailSession(session);
1150
1151                                 throw;
1152                         }
1153                         catch (Exception ex)
1154                         {
1155                                 holder.FailSession(session);
1156
1157                                 throw new ActiveRecordException("Could not perform FindByPrimaryKey for " + targetType.Name + ". Id: " + id, ex);
1158                         }
1159                         finally
1160                         {
1161                                 holder.ReleaseSession(session);
1162                         }
1163                 }
1164
1165                 #endregion
1166
1167                 #region FindFirst
1168
1169                 /// <summary>
1170                 /// Searches and returns the first row.
1171                 /// </summary>
1172                 /// <param name="targetType">The target type.</param>
1173                 /// <param name="detachedCriteria">The criteria.</param>
1174                 /// <param name="orders">The sort order - used to determine which record is the first one.</param>
1175                 /// <returns>A <c>targetType</c> instance or <c>null.</c></returns>
1176                 protected internal static object FindFirst(Type targetType, DetachedCriteria detachedCriteria, params Order[] orders)
1177                 {
1178                         Array result = SlicedFindAll(targetType, 0, 1, orders, detachedCriteria);
1179                         return (result != null && result.Length > 0 ? result.GetValue(0) : null);
1180                 }
1181
1182                 /// <summary>
1183                 /// Searches and returns the first row.
1184                 /// </summary>
1185                 /// <param name="targetType">The target type</param>
1186                 /// <param name="orders">The sort order - used to determine which record is the first one</param>
1187                 /// <param name="criteria">The criteria expression</param>
1188                 /// <returns>A <c>targetType</c> instance or <c>null</c></returns>
1189                 protected internal static object FindFirst(Type targetType, Order[] orders, params ICriterion[] criteria)
1190                 {
1191                         Array result = SlicedFindAll(targetType, 0, 1, orders, criteria);
1192                         return (result != null && result.Length > 0 ? result.GetValue(0) : null);
1193                 }
1194
1195                 /// <summary>
1196                 /// Searches and returns the first row.
1197                 /// </summary>
1198                 /// <param name="targetType">The target type</param>
1199                 /// <param name="criteria">The criteria expression</param>
1200                 /// <returns>A <c>targetType</c> instance or <c>null</c></returns>
1201                 protected internal static object FindFirst(Type targetType, params ICriterion[] criteria)
1202                 {
1203                         return FindFirst(targetType, null, criteria);
1204                 }
1205
1206                 #endregion
1207
1208                 #region FindOne
1209
1210                 /// <summary>
1211                 /// Searches and returns a row. If more than one is found,
1212                 /// throws <see cref="ActiveRecordException"/>
1213                 /// </summary>
1214                 /// <param name="targetType">The target type</param>
1215                 /// <param name="criteria">The criteria expression</param>
1216                 /// <returns>A <c>targetType</c> instance or <c>null</c></returns>
1217                 protected internal static object FindOne(Type targetType, params ICriterion[] criteria)
1218                 {
1219                         Array result = SlicedFindAll(targetType, 0, 2, criteria);
1220
1221                         if (result.Length > 1)
1222                         {
1223                                 throw new ActiveRecordException(targetType.Name + ".FindOne returned " + result.Length +
1224                                                                                                 " rows. Expecting one or none");
1225                         }
1226
1227                         return (result.Length == 0) ? null : result.GetValue(0);
1228                 }
1229
1230                 /// <summary>
1231                 /// Searches and returns a row. If more than one is found,
1232                 /// throws <see cref="ActiveRecordException"/>
1233                 /// </summary>
1234                 /// <param name="targetType">The target type</param>
1235                 /// <param name="criteria">The criteria</param>
1236                 /// <returns>A <c>targetType</c> instance or <c>null</c></returns>
1237                 protected internal static object FindOne(Type targetType, DetachedCriteria criteria)
1238                 {
1239                         Array result = SlicedFindAll(targetType, 0, 2, criteria);
1240
1241                         if (result.Length > 1)
1242                         {
1243                                 throw new ActiveRecordException(targetType.Name + ".FindOne returned " + result.Length +
1244                                                                 " rows. Expecting one or none");
1245                         }
1246
1247                         return (result.Length == 0) ? null : result.GetValue(0);
1248                 }
1249
1250                 #endregion
1251
1252                 #region SlicedFindAll
1253
1254                 /// <summary>
1255                 /// Returns a portion of the query results (sliced)
1256                 /// </summary>
1257                 /// <param name="targetType">The target type.</param>
1258                 /// <param name="firstResult">The number of the first row to retrieve.</param>
1259                 /// <param name="maxResults">The maximum number of results retrieved.</param>
1260                 /// <param name="orders">An <see cref="Array"/> of <see cref="Order"/> objects.</param>
1261                 /// <param name="criteria">The criteria expression</param>
1262                 /// <returns>The sliced query results.</returns>
1263                 protected internal static Array SlicedFindAll(Type targetType, int firstResult, int maxResults,
1264                                                               Order[] orders, params ICriterion[] criteria)
1265                 {
1266                         EnsureInitialized(targetType);
1267
1268                         ISession session = holder.CreateSession(targetType);
1269
1270                         try
1271                         {
1272                                 ICriteria sessionCriteria = session.CreateCriteria(targetType);
1273
1274                                 foreach(ICriterion cond in criteria)
1275                                 {
1276                                         sessionCriteria.Add(cond);
1277                                 }
1278
1279                                 if (orders != null)
1280                                 {
1281                                         foreach (Order order in orders)
1282                                         {
1283                                                 sessionCriteria.AddOrder(order);
1284                                         }
1285                                 }
1286
1287                                 sessionCriteria.SetFirstResult(firstResult);
1288                                 sessionCriteria.SetMaxResults(maxResults);
1289
1290                                 return SupportingUtils.BuildArray(targetType, sessionCriteria.List());
1291                         }
1292                         catch (ValidationException)
1293                         {
1294                                 holder.FailSession(session);
1295
1296                                 throw;
1297                         }
1298                         catch (Exception ex)
1299                         {
1300                                 holder.FailSession(session);
1301
1302                                 throw new ActiveRecordException("Could not perform SlicedFindAll for " + targetType.Name, ex);
1303                         }
1304                         finally
1305                         {
1306                                 holder.ReleaseSession(session);
1307                         }
1308                 }
1309
1310                 /// <summary>
1311                 /// Returns a portion of the query results (sliced)
1312                 /// </summary>
1313                 /// <param name="targetType">The target type.</param>
1314                 /// <param name="firstResult">The number of the first row to retrieve.</param>
1315                 /// <param name="maxResults">The maximum number of results retrieved.</param>
1316                 /// <param name="orders">An <see cref="Array"/> of <see cref="Order"/> objects.</param>
1317                 /// <param name="criteria">The criteria expression</param>
1318                 /// <returns>The sliced query results.</returns>
1319                 protected internal static Array SlicedFindAll(Type targetType, int firstResult, int maxResults,
1320                                                               Order[] orders, DetachedCriteria criteria)
1321                 {
1322                         EnsureInitialized(targetType);
1323
1324                         ISession session = holder.CreateSession(targetType);
1325
1326                         try
1327                         {
1328                                 ICriteria executableCriteria = criteria.GetExecutableCriteria(session);
1329                                 AddOrdersToCriteria(executableCriteria, orders);
1330                                 executableCriteria.SetFirstResult(firstResult);
1331                                 executableCriteria.SetMaxResults(maxResults);
1332
1333                                 return SupportingUtils.BuildArray(targetType, executableCriteria.List());
1334                         }
1335                         catch(ValidationException)
1336                         {
1337                                 holder.FailSession(session);
1338
1339                                 throw;
1340                         }
1341                         catch(Exception ex)
1342                         {
1343                                 holder.FailSession(session);
1344
1345                                 throw new ActiveRecordException("Could not perform SlicedFindAll for " + targetType.Name, ex);
1346                         }
1347                         finally
1348                         {
1349                                 holder.ReleaseSession(session);
1350                         }
1351                 }
1352
1353                 /// <summary>
1354                 /// Returns a portion of the query results (sliced)
1355                 /// </summary>
1356                 /// <param name="targetType">The target type.</param>
1357                 /// <param name="firstResult">The number of the first row to retrieve.</param>
1358                 /// <param name="maxResults">The maximum number of results retrieved.</param>
1359                 /// <param name="criteria">The criteria expression</param>
1360                 /// <returns>The sliced query results.</returns>
1361                 protected internal static Array SlicedFindAll(Type targetType, int firstResult, int maxResults,
1362                                                               params ICriterion[] criteria)
1363                 {
1364                         return SlicedFindAll(targetType, firstResult, maxResults, null, criteria);
1365                 }
1366
1367                 /// <summary>
1368                 /// Returns a portion of the query results (sliced)
1369                 /// </summary>
1370                 /// <param name="targetType">The target type.</param>
1371                 /// <param name="firstResult">The number of the first row to retrieve.</param>
1372                 /// <param name="maxResults">The maximum number of results retrieved.</param>
1373                 /// <param name="criteria">The criteria expression</param>
1374                 /// <returns>The sliced query results.</returns>
1375                 protected internal static Array SlicedFindAll(Type targetType, int firstResult, int maxResults,
1376                                                               DetachedCriteria criteria)
1377                 {
1378                         return SlicedFindAll(targetType, firstResult, maxResults, null, criteria);
1379                 }
1380
1381                 #endregion
1382
1383                 #endregion
1384
1385                 #region protected internal
1386
1387                 /// <summary>
1388                 /// Invokes the specified delegate passing a valid
1389                 /// NHibernate session. Used for custom NHibernate queries.
1390                 /// </summary>
1391                 /// <param name="call">The delegate instance</param>
1392                 /// <returns>Whatever is returned by the delegate invocation</returns>
1393                 protected virtual internal object Execute(NHibernateDelegate call)
1394                 {
1395                         return Execute(GetType(), call, this);
1396                 }
1397
1398                 #endregion
1399
1400                 #region public virtual
1401
1402                 /// <summary>
1403                 /// Saves the instance information to the database.
1404                 /// May Create or Update the instance depending
1405                 /// on whether it has a valid ID.
1406                 /// </summary>
1407                 /// <remarks>
1408                 /// If within a <see cref="SessionScope"/> the operation
1409                 /// is going to be on hold until NHibernate (or you) decides to flush
1410                 /// the session.
1411                 /// </remarks>
1412                 public virtual void Save()
1413                 {
1414                         Save(this);
1415                 }
1416
1417                 /// <summary>
1418                 /// Saves the instance information to the database.
1419                 /// May Create or Update the instance depending
1420                 /// on whether it has a valid ID.
1421                 /// </summary>
1422                 /// <remarks>
1423                 /// Even within a <see cref="SessionScope"/> the operation
1424                 /// is going to be flushed immediately. This might have side effects such as
1425                 /// flushing (persisting) others operations that were on hold.
1426                 /// </remarks>
1427                 public virtual void SaveAndFlush()
1428                 {
1429                         SaveAndFlush(this);
1430                 }
1431
1432         /// <summary>
1433         /// Saves a copy of the instance information to the database.
1434         /// May Create or Update the instance depending
1435         /// on whether it has a valid ID.
1436         /// </summary>
1437         /// <returns>An saved ActiveRecord instance</returns>
1438         /// <remarks>
1439         /// If within a <see cref="SessionScope"/> the operation
1440         /// is going to be on hold until NHibernate (or you) decides to flush
1441         /// the session.
1442         /// </remarks>
1443         public virtual object SaveCopy()
1444         {
1445             return SaveCopy(this);
1446         }
1447
1448         /// <summary>
1449         /// Saves a copy of the instance information to the database.
1450         /// May Create or Update the instance depending
1451         /// on whether it has a valid ID.
1452         /// </summary>
1453         /// <returns>A saved ActiveRecord instance</returns>
1454         /// <remarks>
1455         /// Even within a <see cref="SessionScope"/> the operation
1456         /// is going to be flushed immediately. This might have side effects such as
1457         /// flushing (persisting) others operations that were on hold.
1458         /// </remarks>
1459         public virtual object SaveCopyAndFlush()
1460         {
1461             return SaveCopyAndFlush(this);
1462         }
1463
1464                 /// <summary>
1465                 /// Creates (Saves) a new instance to the database.
1466                 /// </summary>
1467                 /// <remarks>
1468                 /// If within a <see cref="SessionScope"/> the operation
1469                 /// is going to be on hold until NHibernate (or you) decides to flush
1470                 /// the session.
1471                 /// </remarks>
1472                 public virtual void Create()
1473                 {
1474                         Create(this);
1475                 }
1476
1477                 /// <summary>
1478                 /// Creates (Saves) a new instance to the database.
1479                 /// </summary>
1480                 /// <remarks>
1481                 /// Even within a <see cref="SessionScope"/> the operation
1482                 /// is going to be flushed immediately. This might have side effects such as
1483                 /// flushing (persisting) others operations that were on hold.
1484                 /// </remarks>
1485                 public virtual void CreateAndFlush()
1486                 {
1487                         CreateAndFlush(this);
1488                 }
1489
1490                 /// <summary>
1491                 /// Persists the modification on the instance
1492                 /// state to the database.
1493                 /// </summary>
1494                 /// <remarks>
1495                 /// If within a <see cref="SessionScope"/> the operation
1496                 /// is going to be on hold until NHibernate (or you) decides to flush
1497                 /// the session.
1498                 /// </remarks>
1499                 public virtual void Update()
1500                 {
1501                         Update(this);
1502                 }
1503
1504                 /// <summary>
1505                 /// Persists the modification on the instance
1506                 /// state to the database.
1507                 /// </summary>
1508                 /// <remarks>
1509                 /// Even within a <see cref="SessionScope"/> the operation
1510                 /// is going to be flushed immediately. This might have side effects such as
1511                 /// flushing (persisting) others operations that were on hold.
1512                 /// </remarks>
1513                 public virtual void UpdateAndFlush()
1514                 {
1515                         UpdateAndFlush(this);
1516                 }
1517
1518                 /// <summary>
1519                 /// Deletes the instance from the database.
1520                 /// </summary>
1521                 /// <remarks>
1522                 /// If within a <see cref="SessionScope"/> the operation
1523                 /// is going to be on hold until NHibernate (or you) decides to flush
1524                 /// the session.
1525                 /// </remarks>
1526                 public virtual void Delete()
1527                 {
1528                         Delete(this);
1529                 }
1530
1531                 /// <summary>
1532                 /// Deletes the instance from the database.
1533                 /// </summary>
1534                 /// <remarks>
1535                 /// Even within a <see cref="SessionScope"/> the operation
1536                 /// is going to be flushed immediately. This might have side effects such as
1537                 /// flushing (persisting) others operations that were on hold.
1538                 /// </remarks>
1539                 public virtual void DeleteAndFlush()
1540                 {
1541                         DeleteAndFlush(this);
1542                 }
1543
1544                 /// <summary>
1545                 /// Refresh the instance from the database.
1546                 /// </summary>
1547                 public virtual void Refresh()
1548                 {
1549                         Refresh(this);
1550                 }
1551
1552                 #endregion
1553
1554                 #region public override
1555
1556                 /// <summary>
1557                 /// Return the type of the object with its PK value.
1558                 /// Useful for logging/debugging
1559                 /// </summary>
1560                 /// <returns>A string representation of this object.</returns>
1561                 public override String ToString()
1562                 {
1563                         ActiveRecordModel model = GetModel(GetType());
1564
1565                         if (model == null || model.PrimaryKey == null)
1566                         {
1567                                 return base.ToString();
1568                         }
1569
1570                         PrimaryKeyModel pkModel = model.PrimaryKey;
1571
1572                         object pkVal = pkModel.Property.GetValue(this, null);
1573
1574                         return base.ToString() + "#" + pkVal;
1575                 }
1576
1577                 #endregion
1578
1579                 #region Sort Order
1580
1581                 internal static Order[] PropertyNamesToOrderArray(bool asc, params string[] propertyNames)
1582                 {
1583                         Order[] orders = new Order[propertyNames.Length];
1584
1585                         for (int i = 0; i < propertyNames.Length; i++)
1586                         {
1587                                 orders[i] = new Order(propertyNames[i], asc);
1588                         }
1589                         return orders;
1590                 }
1591
1592                 /// <summary>
1593                 /// Ascending Order
1594                 /// </summary>
1595                 /// <remarks>
1596                 /// Returns an array of Ascending <see cref="Order"/> instances specifing which properties to use to
1597                 /// order a result.
1598                 /// </remarks>
1599                 /// <param name="propertyNames">List of property names to order by ascending</param>
1600                 /// <returns>Array of <see cref="Order"/> objects suitable for passing to FindAll and variants</returns>
1601                 public static Order[] Asc(params string[] propertyNames)
1602                 {
1603                         return PropertyNamesToOrderArray(true, propertyNames);
1604                 }
1605
1606                 /// <summary>
1607                 /// Descending Order
1608                 /// </summary>
1609                 /// <remarks>
1610                 /// Returns an array of Descending <see cref="Order"/> instances specifing which properties to use to
1611                 /// order a result.
1612                 /// </remarks>
1613                 /// <param name="propertyNames">List of property names to order by descending</param>
1614                 /// <returns>Array of <see cref="Order"/> objects suitable for passing to FindAll and variants</returns>
1615                 public static Order[] Desc(params string[] propertyNames)
1616                 {
1617                         return PropertyNamesToOrderArray(false, propertyNames);
1618                 }
1619
1620                 #endregion
1621         }
1622 }