/// <summary> /// Create a new instance of <see cref="QueryRowsCounter"/>. /// </summary> /// <param name="hqlRowsCount">The HQL.</param> /// <remarks> /// If the query is invalid an exception is throw only when <see cref="IRowsCounter.GetRowsCount(ISession)"/> /// is called. /// </remarks> /// <exception cref="ArgumentNullException">If <paramref name="hqlRowsCount"/> is null or empty.</exception> public QueryRowsCounter(string hqlRowsCount) { if(string.IsNullOrEmpty(hqlRowsCount)) { throw new ArgumentNullException(hqlRowsCount); } detachedQuery = new DetachedQuery(hqlRowsCount); }
/// <summary> /// Create a new instance of <see cref="QueryRowsCounter"/>. /// </summary> /// <param name="queryRowCount">The query.</param> /// <remarks> /// If the query is invalid an exception is throw only when <see cref="IRowsCounter.GetRowsCount(ISession)"/> /// is called. /// </remarks> /// <exception cref="ArgumentNullException">If <paramref name="queryRowCount"/> is null.</exception> public QueryRowsCounter(IDetachedQuery queryRowCount) { if (queryRowCount == null) { throw new ArgumentNullException("queryRowCount"); } dq = queryRowCount; }
/// <summary> /// Copy all properties to a given <see cref="IDetachedQuery"/>. /// </summary> /// <param name="destination">The given <see cref="IDetachedQuery"/>.</param> /// <remarks> /// The method use <see cref="IDetachedQuery"/> to set properties of <paramref name="destination"/>. /// </remarks> public void CopyTo(IDetachedQuery destination) { destination.SetMaxResults(selection.MaxRows) .SetFirstResult(selection.FirstRow) .SetCacheable(cacheable) .SetReadOnly(readOnly) .SetTimeout(selection.Timeout) .SetFlushMode(flushMode); if (!string.IsNullOrEmpty(cacheRegion)) destination.SetCacheRegion(cacheRegion); if (cacheMode.HasValue) destination.SetCacheMode(cacheMode.Value); if (resultTransformer != null) destination.SetResultTransformer(resultTransformer); foreach (KeyValuePair<string, LockMode> mode in lockModes) destination.SetLockMode(mode.Key, mode.Value); SetParametersTo(destination); }
/// <summary> /// Check if there is any records in the db for the target type /// </summary> /// <param name="targetType">The target type.</param> /// <param name="detachedQuery"></param> /// <returns><c>true</c> if there's at least one row</returns> protected internal static bool Exists(Type targetType, IDetachedQuery detachedQuery) { Array array = SlicedFindAll(targetType, 0, 1, detachedQuery); return array.Length > 0; }
public NoFooPaginable(ISession session, IDetachedQuery detachedQuery) : base(session, detachedQuery) { detachedQuery.SetResultTransformer( new PositionalToBeanResultTransformer(typeof(NoFoo), new string[] { "name", "description" })); }
public static Blog[] SlicedFindAll(int FirstResult, int MaxResult, IDetachedQuery dq) { return (Blog[]) SlicedFindAll(typeof(Blog), FirstResult, MaxResult, dq); }
/// <summary> /// Searches and returns a row. If more than one is found, /// throws <see cref="ActiveRecordException"/> /// </summary> /// <param name="targetType">The target type</param> /// <param name="detachedQuery">The query expression</param> /// <returns>A <c>targetType</c> instance or <c>null</c></returns> protected internal static object FindOne(Type targetType, IDetachedQuery detachedQuery) { Array array = SlicedFindAll(targetType, 0, 2, detachedQuery); if (array.Length > 1) { throw new ActiveRecordException( string.Concat( new object[] { targetType.Name, ".FindOne returned ", array.Length, " rows. Expecting one or none" })); } if (array.Length != 0) { return array.GetValue(0); } return null; }
public WrongImplementation(IDetachedQuery dq) { this.dq = dq; }
/// <summary> /// Returns all instances found for the specified type according to the criteria /// </summary> /// <param name="detachedQuery">The query expression.</param> /// <returns>All entities that match the query</returns> public static T[] FindAll(IDetachedQuery detachedQuery) { return((T[])FindAll(typeof(T), detachedQuery)); }
/// <summary> /// Searches and returns a row. If more than one is found, /// throws <see cref="ActiveRecordException"/> /// </summary> /// <param name="targetType">The target type</param> /// <param name="detachedQuery">The query expression</param> /// <returns>A <c>targetType</c> instance or <c>null</c></returns> public static object FindOne(Type targetType, IDetachedQuery detachedQuery) { return(ActiveRecordBase.FindOne(targetType, detachedQuery)); }
/// <summary> /// Check if any instance matches the query. /// </summary> /// <param name="targetType">target Type</param> /// <param name="detachedQuery">The query expression</param> /// <returns><c>true</c> if an instance is found; otherwise <c>false</c>.</returns> public static bool Exists(Type targetType, IDetachedQuery detachedQuery) { return ActiveRecordBase.Exists(targetType, detachedQuery); }
/// <summary> /// Check if any instance matches the query. /// </summary> /// <param name="detachedQuery">The query expression</param> /// <returns><c>true</c> if an instance is found; otherwise <c>false</c>.</returns> public static bool Exists <T>(IDetachedQuery detachedQuery) where T : class { return(AR.CurrentScope().Exists <T>(detachedQuery)); }
/// <summary> /// Searches and returns a row. If more than one is found, /// throws <see cref="ActiveRecordException"/> /// </summary> /// <param name="detachedQuery">The query expression</param> /// <returns>A <c>targetType</c> instance or <c>null</c></returns> public static T FindOne <T>(IDetachedQuery detachedQuery) where T : class { return(AR.CurrentScope().FindOne <T>(detachedQuery)); }
/// <summary> /// Set only parameters to a given <see cref="IDetachedQuery"/>. /// </summary> /// <param name="destination">The given <see cref="IDetachedQuery"/>.</param> /// <remarks> /// The method use <see cref="IDetachedQuery"/> to set properties of <paramref name="destination"/>. /// Existing parameters in <paramref name="destination"/> are merged/overriden. /// </remarks> public void SetParametersTo(IDetachedQuery destination) { foreach (var obj in optionalUntypeParams) destination.SetProperties(obj); // Set untyped positional parameters foreach (var pup in posUntypeParams) destination.SetParameter(pup.Key, pup.Value); // Set untyped named parameters foreach (var nup in namedUntypeParams) destination.SetParameter(nup.Key, nup.Value); // Set untyped named parameters list foreach (var nulp in namedUntypeListParams) destination.SetParameterList(nulp.Key, nulp.Value); // Set typed positional parameters foreach (var pp in posParams) destination.SetParameter(pp.Key, pp.Value.Value, pp.Value.Type); // Set typed named parameters foreach (var np in namedParams) destination.SetParameter(np.Key, np.Value.Value, np.Value.Type); // Set typed named parameters List foreach (var nlp in namedListParams) destination.SetParameterList(nlp.Key, (IEnumerable) nlp.Value.Value, nlp.Value.Type); }
/// <summary> /// Returns a portion of the query results (sliced) /// </summary> /// <param name="firstResult">The number of the first row to retrieve.</param> /// <param name="maxResults">The maximum number of results retrieved.</param> /// <returns>The sliced query results.</returns> /// <param name="detachedQuery">The query expression</param> public static T[] SlicedFindAll(int firstResult, int maxResults, IDetachedQuery detachedQuery) { return((T[])SlicedFindAll(typeof(T), firstResult, maxResults, detachedQuery)); }
/// <summary> /// Searches and returns a row. If more than one is found, /// throws <see cref="ActiveRecordException"/> /// <param name="detachedQuery">The query expression</param> /// </summary> /// <returns>A <c>targetType</c> instance or <c>null</c></returns> public static T FindOne(IDetachedQuery detachedQuery) { return((T)FindOne(typeof(T), detachedQuery)); }
public new void CopyTo(IDetachedQuery destination) { base.CopyTo(destination); }
/// <summary> /// Returns a portion of the query results (sliced) /// </summary> /// <param name="targetType">The target type.</param> /// <param name="firstResult">The number of the first row to retrieve.</param> /// <param name="maxResults">The maximum number of results retrieved.</param> /// <param name="detachedQuery">The query expression</param> /// <returns>The sliced query results.</returns> public static Array SlicedFindAll(Type targetType, int firstResult, int maxResults, IDetachedQuery detachedQuery) { return(ActiveRecordBase.SlicedFindAll(targetType, firstResult, maxResults, detachedQuery)); }
public T FindUnique(IDetachedQuery query) { return(query.GetExecutableQuery(Session).UniqueResult <T>()); }
private IList <T> InternalExecute(IDetachedQuery query) { return(query.GetExecutableQuery(GetSession()).List <T>()); }
/// <summary> /// Searches and returns a row. If more than one is found, /// throws <see cref="ActiveRecordException"/> /// </summary> /// <param name="targetType">The target type</param> /// <param name="detachedQuery">The query expression</param> /// <returns>A <c>targetType</c> instance or <c>null</c></returns> public static object FindOne(Type targetType, IDetachedQuery detachedQuery) { return ActiveRecordBase.FindOne(targetType, detachedQuery); }
public static Blog FindOne(IDetachedQuery dq) { return (Blog) FindOne(typeof(Blog), dq); }
/// <summary> /// Returns all instances found for the specified type according to the criteria /// </summary> /// <param name="targetType">The target type.</param> /// <param name="detachedQuery">The query expression</param> /// <returns>The <see cref="Array"/> of results.</returns> public static Array FindAll(Type targetType, IDetachedQuery detachedQuery) { return(ActiveRecordBase.FindAll(targetType, detachedQuery)); }
/// <summary> /// Check if any instance matching the query exists in the database. /// </summary> /// <param name="detachedQuery">The query expression</param> /// <returns>true if an instance is found; otherwise false.</returns> public static bool Exists(IDetachedQuery detachedQuery) { return(Exists(typeof(T), detachedQuery)); }
public static Blog[] FindAll(IDetachedQuery dq) { return (Blog[]) FindAll(typeof(Blog), dq); }
/// <summary> /// Check if any instance matches the query. /// </summary> /// <param name="targetType">target Type</param> /// <param name="detachedQuery">The query expression</param> /// <returns><c>true</c> if an instance is found; otherwise <c>false</c>.</returns> public static bool Exists(Type targetType, IDetachedQuery detachedQuery) { return(ActiveRecordBase.Exists(targetType, detachedQuery)); }
public static bool Exists(IDetachedQuery dq) { return Exists(typeof(Blog), dq); }
/// <summary> /// Searches and returns the first row. /// </summary> /// <param name="targetType">The target type.</param> /// <param name="detachedQuery">The expression query.</param> /// <returns>A <c>targetType</c> instance or <c>null.</c></returns> protected internal static object FindFirst(Type targetType, IDetachedQuery detachedQuery) { Array array = SlicedFindAll(targetType, 0, 1, detachedQuery); if ((array != null) && (array.Length > 0)) { return array.GetValue(0); } return null; }
public static Blog[] FindAll(IDetachedQuery dq) { return((Blog[])FindAll(typeof(Blog), dq)); }
/// <summary> /// Returns a portion of the query results (sliced) /// </summary> /// <param name="targetType">The target type.</param> /// <param name="firstResult">The number of the first row to retrieve.</param> /// <param name="maxResults">The maximum number of results retrieved.</param> /// <param name="detachedQuery">The query expression</param> /// <returns>The sliced query results.</returns> public static Array SlicedFindAll(Type targetType, int firstResult, int maxResults, IDetachedQuery detachedQuery) { EnsureInitialized(targetType); ISession session = holder.CreateSession(targetType); try { IQuery executableQuery = detachedQuery.GetExecutableQuery(session); executableQuery.SetFirstResult(firstResult); executableQuery.SetMaxResults(maxResults); return SupportingUtils.BuildArray(targetType, executableQuery.List()); } catch (ValidationException) { holder.FailSession(session); throw; } catch (Exception exception) { holder.FailSession(session); throw new ActiveRecordException("Could not perform SlicedFindAll for " + targetType.Name, exception); } finally { holder.ReleaseSession(session); } }
public static Blog FindOne(IDetachedQuery dq) { return((Blog)FindOne(typeof(Blog), dq)); }
/// <summary> /// Returns all instances found for the specified type according to the criteria /// </summary> /// <param name="targetType">The target type.</param> /// <param name="detachedQuery">The query expression</param> /// <returns>The <see cref="Array"/> of results.</returns> protected internal static Array FindAll(Type targetType, IDetachedQuery detachedQuery) { EnsureInitialized(targetType); ISession session = holder.CreateSession(targetType); try { IQuery executableQuery = detachedQuery.GetExecutableQuery(session); return SupportingUtils.BuildArray(targetType, executableQuery.List()); } catch (ValidationException) { holder.FailSession(session); throw; } catch (Exception exception) { holder.FailSession(session); throw new ActiveRecordException("Could not perform FindAll for " + targetType.Name, exception); } finally { holder.ReleaseSession(session); } }
public static bool Exists(IDetachedQuery dq) { return(Exists(typeof(Blog), dq)); }
/// <summary> /// Set only parameters to a given <see cref="IDetachedQuery"/>. /// </summary> /// <param name="destination">The given <see cref="IDetachedQuery"/>.</param> /// <remarks> /// The method use <see cref="IDetachedQuery"/> to set properties of <paramref name="destination"/>. /// Existing parameters in <paramref name="destination"/> are merged/overriden. /// </remarks> public void SetParametersTo(IDetachedQuery destination) { foreach (object obj in optionalUntypeParams) destination.SetProperties(obj); // Set untyped positional parameters foreach (KeyValuePair<int, object> pup in posUntypeParams) destination.SetParameter(pup.Key, pup.Value); // Set untyped named parameters foreach (KeyValuePair<string, object> nup in namedUntypeParams) destination.SetParameter(nup.Key, nup.Value); // Set untyped named parameters list foreach (KeyValuePair<string, ICollection> nulp in namedUntypeListParams) destination.SetParameterList(nulp.Key, nulp.Value); // Set typed positional parameters foreach (KeyValuePair<int, TypedValue> pp in posParams) destination.SetParameter(pp.Key, pp.Value.Value, pp.Value.Type); // Set typed named parameters foreach (KeyValuePair<string, TypedValue> np in namedParams) destination.SetParameter(np.Key, np.Value.Value, np.Value.Type); // Set typed named parameters List foreach (KeyValuePair<string, TypedValue> nlp in namedListParams) destination.SetParameterList(nlp.Key, (ICollection)nlp.Value.Value, nlp.Value.Type); }
public static Blog[] SlicedFindAll(int FirstResult, int MaxResult, IDetachedQuery dq) { return((Blog[])SlicedFindAll(typeof(Blog), FirstResult, MaxResult, dq)); }
public IList <T> Find(IDetachedQuery query) { return(query.GetExecutableQuery(Session).List <T>()); }
/// <summary> /// Searches and returns a row. If more than one is found, /// throws <see cref="ActiveRecordException"/> /// <param name="detachedQuery">The query expression</param> /// </summary> /// <returns>A <c>targetType</c> instance or <c>null</c></returns> public static T FindOne(IDetachedQuery detachedQuery) { return(AR.CurrentScope().FindOne <T>(detachedQuery)); }
// Override this method to check the type of 'query' param to provide some type of // PaginableRowCount. // for example: // -secure if query is the implementation of DetachedDynQuery you can use PaginableDynQuery // -some times if the query is an implementation of DetachedQuery (see PaginableRowsCounterQuery for instance) public virtual IPaginable <T> GetPaginable(IDetachedQuery query) { return(new PaginableQuery <T>(Session, query)); }
/// <summary> /// Returns all instances found for the specified type according to the criteria /// </summary> /// <param name="detachedQuery">The query expression.</param> /// <returns>All entities that match the query</returns> public static IEnumerable <T> FindAll(IDetachedQuery detachedQuery) { return(AR.CurrentScope().FindAll <T>(detachedQuery)); }
/// <summary> /// Returns all instances found for the specified type according to the criteria /// </summary> /// <param name="targetType">The target type.</param> /// <param name="detachedQuery">The query expression</param> /// <returns>The <see cref="Array"/> of results.</returns> public static Array FindAll(Type targetType, IDetachedQuery detachedQuery) { return ActiveRecordBase.FindAll(targetType, detachedQuery); }
/// <summary> /// Returns a portion of the query results (sliced) /// </summary> /// <param name="firstResult">The number of the first row to retrieve.</param> /// <param name="maxResults">The maximum number of results retrieved.</param> /// <returns>The sliced query results.</returns> /// <param name="detachedQuery">The query expression</param> public static IEnumerable <T> SlicedFindAll(int firstResult, int maxResults, IDetachedQuery detachedQuery) { return(AR.CurrentScope().SlicedFindAll <T>(firstResult, maxResults, detachedQuery)); }
/// <summary> /// Returns a portion of the query results (sliced) /// </summary> /// <param name="targetType">The target type.</param> /// <param name="firstResult">The number of the first row to retrieve.</param> /// <param name="maxResults">The maximum number of results retrieved.</param> /// <param name="detachedQuery">The query expression</param> /// <returns>The sliced query results.</returns> public static Array SlicedFindAll(Type targetType, int firstResult, int maxResults, IDetachedQuery detachedQuery) { return ActiveRecordBase.SlicedFindAll(targetType, firstResult, maxResults, detachedQuery); }
/// <summary> /// Check if any instance matches the query. /// </summary> /// <param name="detachedQuery">The query expression</param> /// <returns><c>true</c> if an instance is found; otherwise <c>false</c>.</returns> public static bool Exists(IDetachedQuery detachedQuery) { return(AR.CurrentScope().Exists <T>(detachedQuery)); }