NHibernate.QueryBuilder 1.1.0

How to use it?

Simple example illustrating preferred conventions:

1. Implementing a query class

  internal enum UserAlias  {
      Role,
      Right,
      Group
  }

  internal class UsersQuery : Query<UserPersistent, UserAlias>
  {
      private readonly RolePersistent _role = null;
      private readonly RightPersistent _right = null;
      private readonly GroupPersistent _group = null;

      protected override IDictionary<UserAlias, string> Aliases => 
          new Dictionary<UserAlias, string>
          {
              [UserAlias.Role] = nameof(_role),
              [UserAlias.Right] = nameof(_right),
              [UserAlias.Group] = nameof(_group)
          };
      

      internal UsersQuery WithRolesAndRights()
      {
          Query = Query
              .Left.JoinAlias(usr => usr.Roles, () => _role)
              .Left.JoinAlias(() => _role.Rights, () => _right);
          return this;
      }

      internal UsersQuery WithGroups()
      {
          Query = Query.Left.JoinAlias(usr => usr.Groups, () => _group);
          return this;
      }
  }

2. Creating QueryBuilder for above:

  var builder = new QueryBuilder<UserPersistent, UserAlias>(session);

3. Performing a query (let's say it's a very uncommon case, in which we want to find users who have role similar to 'Admin', are in a specific group type and are from within several countries - just for a demonstration purpose)

  public IEnumerable<User> FindUsersByWeirdCriteria(GroupType type, string[] countries)
  {
      IEnumerable<UserPersistent> users = builder.NewQuery()
          .WithRolesAndRights()
          .WithGroups()
          .Restrict.Like<RolePersistent>(UserAlias.Role, role => role.Name, 'Admin')
          .Restrict.In(usr => usr.Country, countries)
          .Restrict.Eq<GroupPersistent>(UserAlias.Group, grp => grp.Type, groupType)
          .Build()
          .List();

      //some mapping logic
      return users.Select(usr => mapper.MapToEntity(usr));
  }

One thing to notice - restrictions made on aliased classes require usage of <T> typed methods in contrast to methods working directly on type of query (TPersistent) where only property selector and value is required (see Restrict.In method call above). Alias resolution by key, and not only by type, is required to distinguish multiple join operations to the same table and add restrictions to the desired operation.