Example #1
0
        /// <summary>
        /// Executes the query and return a strongly typed result
        /// </summary>
        /// <param name="query">The query.</param>
        /// <returns>The query result.</returns>
        protected internal static R ExecuteQuery2 <R>(IActiveRecordQuery <R> query)
        {
            object result = ExecuteQuery(query);

            if (result == null)
            {
                return(default(R));
            }

            if (!typeof(R).IsAssignableFrom(result.GetType()))
            {
                throw new NHibernate.QueryException(
                          string.Format("Problem: A query was executed requesting {0} as result, but the query returned an object of type {1}.", typeof(R).Name, result.GetType().Name));
            }
            return((R)result);
        }
Example #2
0
        protected internal static object ExecuteQuery(IActiveRecordQuery q)
        {
            Type targetType = q.TargetType;

            EnsureInitialized(targetType);

            ISession session = _holder.CreateSession(targetType);

            try
            {
                return(q.Execute(session));
            }
            catch (Exception ex)
            {
                throw new ActiveRecordException("Could not perform Execute for " + targetType.Name, ex);
            }
            finally
            {
                _holder.ReleaseSession(session);
            }
        }
 /// <summary>
 /// Executes the query
 /// </summary>
 /// <param name="q">The query</param>
 /// <returns></returns>
 public static object ExecuteQuery(IActiveRecordQuery q)
 {
     return ActiveRecordBase.ExecuteQuery(q);
 }
 /// <summary>
 /// Enumerates the query.
 /// Note: Only use if you expect most of the values to be on the second level cache
 /// </summary>
 /// <param name="q">The query</param>
 /// <returns></returns>
 public static IEnumerable EnumerateQuery(IActiveRecordQuery q)
 {
     return ActiveRecordBase.EnumerateQuery(q);
 }
Example #5
0
        /// <summary>
        /// Executes the query.
        /// </summary>
        /// <param name="query">The query.</param>
        /// <returns>The query result.</returns>
        public static object ExecuteQuery(IActiveRecordQuery query)
        {
            Type rootType = query.RootType;

            EnsureInitialized(rootType);

            ISession session = holder.CreateSession(rootType);

            try
            {
                return query.Execute(session);
            }
            catch (Exception ex)
            {
                holder.FailSession(session);

                throw new ActiveRecordException("Could not perform ExecuteQuery for " + rootType.Name, ex);
            }
            finally
            {
                holder.ReleaseSession(session);
            }
        }
Example #6
0
 public static object Execute(IActiveRecordQuery query)
 {
     return(ExecuteQuery(query));
 }
Example #7
0
 /// <summary>
 /// Executes the query
 /// </summary>
 /// <param name="q">The query</param>
 /// <returns></returns>
 public static object ExecuteQuery(IActiveRecordQuery q)
 {
     return(ActiveRecordBase.ExecuteQuery(q));
 }
			public QueryResults(IActiveRecordQuery q)
			{
				r = (Array) ActiveRecordMediator.ExecuteQuery(q);
			}
Example #9
0
 /// <summary>
 /// Enumerates the query.
 /// Note: Only use if you expect most of the values to be on the second level cache
 /// </summary>
 /// <param name="q">The query</param>
 /// <returns></returns>
 public static IEnumerable EnumerateQuery(IActiveRecordQuery q)
 {
     return(ActiveRecordBase.EnumerateQuery(q));
 }
 public QueryResults(IActiveRecordQuery q)
 {
     r = (Array)ActiveRecordMediator.ExecuteQuery(q);
 }
 /// <summary>
 /// Executes the query and return a strongly typed result
 /// </summary>
 /// <param name="query">The query.</param>
 /// <returns></returns>
 public static R ExecuteQuery2 <R>(IActiveRecordQuery <R> query)
 {
     return(ActiveRecordBase <T> .ExecuteQuery2(query));
 }