/// <summary> /// Retrieves entities of the type 'MUserEntity' in a datatable which match the specified filter. /// It will always create a new connection to the database. /// </summary> /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. /// If the used Dynamic Query Engine supports it, 'TOP' is used to limit the amount of rows to return. /// When set to 0, no limitations are specified.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param> /// <param name="selectFilter">A predicate or predicate expression which should be used as filter for the entities to retrieve.</param> /// <param name="relations">The set of relations to walk to construct to total query.</param> /// <param name="pageNumber">The page number to retrieve.</param> /// <param name="pageSize">The page size of the page to retrieve.</param> /// <returns>a filled datatable if succeeded, false otherwise</returns> public virtual DataTable GetMultiAsDataTable(long maxNumberOfItemsToReturn, ISortExpression sortClauses, IPredicate selectFilter, IRelationCollection relations, int pageNumber, int pageSize) { return base.PerformGetMultiAsDataTableAction(maxNumberOfItemsToReturn, sortClauses, selectFilter, relations, pageNumber, pageSize); }
/// <summary> /// Retrieves entities of the type 'AttributeMatchEntity' in a datatable which match the specified filter. /// It will always create a new connection to the database. /// </summary> /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. /// If the used Dynamic Query Engine supports it, 'TOP' is used to limit the amount of rows to return. /// When set to 0, no limitations are specified.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param> /// <param name="selectFilter">A predicate or predicate expression which should be used as filter for the entities to retrieve.</param> /// <param name="relations">The set of relations to walk to construct to total query.</param> /// <param name="pageNumber">The page number to retrieve.</param> /// <param name="pageSize">The page size of the page to retrieve.</param> /// <returns>a filled datatable if succeeded, false otherwise</returns> public virtual DataTable GetMultiAsDataTable(long maxNumberOfItemsToReturn, ISortExpression sortClauses, IPredicate selectFilter, IRelationCollection relations, int pageNumber, int pageSize) { return(base.PerformGetMultiAsDataTableAction(maxNumberOfItemsToReturn, sortClauses, selectFilter, relations, pageNumber, pageSize)); }
/// <summary> /// Retrieves rows in the datatable provided which match the specified filter, containing the fields specified. It will always create a new connection to the database. /// </summary> /// <param name="fieldsToReturn">IEntityFields implementation which forms the definition of the resultset to return.</param> /// <param name="tableToFill">The datatable to fill with the rows retrieved</param> /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. /// If the used Dynamic Query Engine supports it, 'TOP' is used to limit the amount of rows to return. When set to 0, no limitations are specified.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When null is specified, no sorting is applied.</param> /// <param name="selectFilter">A predicate or predicate expression which should be used as filter for the entities to retrieve.</param> /// <param name="relations">The set of relations to walk to construct to total query.</param> /// <param name="allowDuplicates">Flag to allow duplicate rows or not</param> /// <param name="groupByClause">The list of fields to group by on. When not specified or an empty collection is specified, no group by clause /// is added to the query. A check is performed for each field in the selectList. If a field in the selectList is not present in the groupByClause collection, an exception is thrown.</param> /// <param name="transactionToUse">The transaction object to use. Can be null. If specified, the connection object of the transaction is used to fill the TypedView, which avoids deadlocks on SqlServer.</param> /// <param name="pageNumber">The page number to retrieve.</param> /// <param name="pageSize">The page size of the page to retrieve.</param> /// <returns>true if succeeded, false otherwise</returns> public bool GetMultiAsDataTable(IEntityFields fieldsToReturn, DataTable tableToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IPredicate selectFilter, IRelationCollection relations, bool allowDuplicates, IGroupByCollection groupByClause, ITransaction transactionToUse, int pageNumber, int pageSize) { return base.PerformGetMultiAsDataTableAction(fieldsToReturn, tableToFill, maxNumberOfItemsToReturn, sortClauses, selectFilter, relations, allowDuplicates, groupByClause, transactionToUse, pageNumber, pageSize); }
/// <summary> Retrieves Entity rows in a datatable which match the specified filter. It will always create a new connection to the database.</summary> /// <param name="selectFilter">A predicate or predicate expression which should be used as filter for the entities to retrieve.</param> /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param> /// <param name="relations">The set of relations to walk to construct to total query.</param> /// <param name="pageNumber">The page number to retrieve.</param> /// <param name="pageSize">The page size of the page to retrieve.</param> /// <returns>DataTable with the rows requested.</returns> public static DataTable GetMultiAsDataTable(IPredicate selectFilter, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IRelationCollection relations, int pageNumber, int pageSize) { AnalysisResultDAO dao = DAOFactory.CreateAnalysisResultDAO(); return(dao.GetMultiAsDataTable(maxNumberOfItemsToReturn, sortClauses, selectFilter, relations, pageNumber, pageSize)); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <param name="filter">The filter to apply to retrieve the scalar</param> /// <param name="relations">The relations to walk</param> /// <param name="groupByClause">The groupby clause to apply to retrieve the scalar</param> /// <returns>the scalar value requested</returns> public virtual object GetScalar(AnalysisResultFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply, IPredicate filter, IRelationCollection relations, IGroupByCollection groupByClause) { EntityFields fields = new EntityFields(1); fields[0] = EntityFieldFactory.Create(fieldIndex); if ((fields[0].ExpressionToApply == null) || (expressionToExecute != null)) { fields[0].ExpressionToApply = expressionToExecute; } if ((fields[0].AggregateFunctionToApply == AggregateFunction.None) || (aggregateToApply != AggregateFunction.None)) { fields[0].AggregateFunctionToApply = aggregateToApply; } return(DAOFactory.CreateAnalysisResultDAO().GetScalar(fields, this.Transaction, filter, relations, groupByClause)); }
/// <summary> Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <param name="filter">The filter to apply to retrieve the scalar</param> /// <param name="relations">The relations to walk</param> /// <param name="groupByClause">The groupby clause to apply to retrieve the scalar</param> /// <returns>the scalar value requested</returns> public virtual object GetScalar(ObserverDataSetFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply, IPredicate filter, IRelationCollection relations, IGroupByCollection groupByClause) { EntityFields fields = new EntityFields(1); fields[0] = EntityFieldFactory.Create(fieldIndex); if ((fields[0].ExpressionToApply == null) || (expressionToExecute != null)) { fields[0].ExpressionToApply = expressionToExecute; } if ((fields[0].AggregateFunctionToApply == AggregateFunction.None) || (aggregateToApply != AggregateFunction.None)) { fields[0].AggregateFunctionToApply = aggregateToApply; } ObserverDataSetDAO dao = DAOFactory.CreateObserverDataSetDAO(); return(dao.GetScalar(fields, base.Transaction, filter, relations, groupByClause)); }
/// <summary> Retrieves Entity rows in a datatable which match the specified filter. It will always create a new connection to the database.</summary> /// <param name="selectFilter">A predicate or predicate expression which should be used as filter for the entities to retrieve.</param> /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param> /// <param name="relations">The set of relations to walk to construct to total query.</param> /// <returns>DataTable with the rows requested.</returns> public static DataTable GetMultiAsDataTable(IPredicate selectFilter, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IRelationCollection relations) { return(GetMultiAsDataTable(selectFilter, maxNumberOfItemsToReturn, sortClauses, relations, 0, 0)); }
/// <summary> Deletes from the persistent storage all AuditInfo entities which match with the specified filter, formulated in the predicate or predicate expression definition.</summary> /// <param name="deleteFilter">A predicate or predicate expression which should be used as filter for the entities to delete.</param> /// <param name="relations">The set of relations to walk to construct the total query.</param> /// <returns>Amount of entities affected, if the used persistent storage has rowcounting enabled.</returns> public override int DeleteMulti(IPredicate deleteFilter, IRelationCollection relations) { throw new NotSupportedException("This method isn't supported for this entity"); }
/// <summary>Retrieves Entity rows in a datatable which match the specified filter. It will always create a new connection to the database.</summary> /// <param name="selectFilter">A predicate or predicate expression which should be used as filter for the entities to retrieve.</param> /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param> /// <param name="relations">The set of relations to walk to construct to total query.</param> /// <param name="pageNumber">The page number to retrieve.</param> /// <param name="pageSize">The page size of the page to retrieve.</param> /// <returns>DataTable with the rows requested.</returns> public static DataTable GetMultiAsDataTable(IPredicate selectFilter, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IRelationCollection relations, int pageNumber, int pageSize) { return(DAOFactory.CreateAuditActionTypeDAO().GetMultiAsDataTable(maxNumberOfItemsToReturn, sortClauses, selectFilter, relations, pageNumber, pageSize)); }
/// <summary> /// Creates a new Select Query which is ready to use, based on the specified select list and the specified set of relations. /// If selectFilter is set to null, all rows are selected. /// </summary> /// <param name="selectList">list of IEntityFieldCore objects to select</param> /// <param name="fieldsPersistenceInfo">Array of IFieldPersistenceInfo objects to use to build the select query</param> /// <param name="connectionToUse">The connection to use for the query</param> /// <param name="selectFilter">A complete IPredicate implementing object which contains the filter for the rows to select. When set to null, no /// filtering is done, and all rows are returned.</param> /// <param name="rowsToSkip">The rows to skip. Default 0</param> /// <param name="rowsToTake">The rows to take. Default 0, which means all.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param> /// <param name="relationsToWalk">list of EntityRelation objects, which will be used to formulate a FROM clause with INNER JOINs.</param> /// <param name="allowDuplicates">Flag which forces the inclusion of DISTINCT if set to true. If the resultset contains fields of type ntext, text or image, no duplicate filtering /// is done.</param> /// <param name="groupByClause">The list of fields to group by on. When not specified or an empty collection is specified, no group by clause /// is added to the query. A check is performed for each field in the selectList. If a field in the selectList is not present in the groupByClause /// collection, an exception is thrown.</param> /// <returns> /// IRetrievalQuery instance which is ready to be used. /// </returns> /// <exception cref="System.ArgumentNullException">When selectList is null or fieldsPersistenceInfo is null or relationsToWalk is null</exception> /// <exception cref="System.ArgumentException">When selectList contains no EntityFieldCore instances or fieldsPersistenceInfo is empty.</exception> /// <remarks> /// Generic version /// </remarks> protected override IRetrievalQuery CreatePagingSelectDQ(IEntityFieldCore[] selectList, IFieldPersistenceInfo[] fieldsPersistenceInfo, DbConnection connectionToUse, IPredicate selectFilter, int rowsToSkip, int rowsToTake, ISortExpression sortClauses, IRelationCollection relationsToWalk, bool allowDuplicates, IGroupByCollection groupByClause) { TraceHelper.WriteLineIf(Switch.TraceInfo, "CreatePagingSelectDQ", "Method Enter"); long max = 0; bool pagingRequired = true; if (rowsToSkip <= 0) { // no paging. max = rowsToTake; pagingRequired = false; } IRetrievalQuery normalQuery = this.CreateSelectDQ(selectList, fieldsPersistenceInfo, connectionToUse, selectFilter, max, sortClauses, relationsToWalk, allowDuplicates, groupByClause); if (!pagingRequired) { TraceHelper.WriteLineIf(Switch.TraceInfo, "CreatePagingSelectDQ: no paging.", "Method Exit"); return(normalQuery); } bool emitQueryToTrace = false; if (normalQuery.RequiresClientSideDistinctFiltering) { // manual paging required normalQuery.RequiresClientSidePaging = pagingRequired; normalQuery.ManualRowsToSkip = rowsToSkip; normalQuery.ManualRowsToTake = rowsToTake; } else { // normal paging. Embed paging logic. There is no TOP statement in the query as we've passed '0' for maxAmountOfItemsToReturn string upperLimitSnippet = string.Empty; if (rowsToTake > 0) { upperLimitSnippet = string.Format(" TOP {0}", rowsToTake); } if (normalQuery.Command.CommandText.ToLowerInvariant().StartsWith("select distinct")) { normalQuery.Command.CommandText = String.Format("SELECT DISTINCT{0} START AT {1} {2}", upperLimitSnippet, rowsToSkip + 1, normalQuery.Command.CommandText.Substring(16)); } else { normalQuery.Command.CommandText = String.Format("SELECT{0} START AT {1} {2}", upperLimitSnippet, rowsToSkip + 1, normalQuery.Command.CommandText.Substring(7)); } emitQueryToTrace = true; } TraceHelper.WriteIf(Switch.TraceVerbose && emitQueryToTrace, normalQuery, "Generated Sql query"); TraceHelper.WriteLineIf(Switch.TraceInfo, "CreatePagingSelectDQ", "Method Exit"); return(normalQuery); }
/// <summary> /// Retrieves rows in the datatable provided which match the specified filter, containing the fields specified. It will always create a new connection to the database. /// </summary> /// <param name="fieldsToReturn">IEntityFields implementation which forms the definition of the resultset to return.</param> /// <param name="tableToFill">The datatable to fill with the rows retrieved</param> /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query. /// If the used Dynamic Query Engine supports it, 'TOP' is used to limit the amount of rows to return. When set to 0, no limitations are specified.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When null is specified, no sorting is applied.</param> /// <param name="selectFilter">A predicate or predicate expression which should be used as filter for the entities to retrieve.</param> /// <param name="relations">The set of relations to walk to construct to total query.</param> /// <param name="allowDuplicates">Flag to allow duplicate rows or not</param> /// <param name="groupByClause">The list of fields to group by on. When not specified or an empty collection is specified, no group by clause /// is added to the query. A check is performed for each field in the selectList. If a field in the selectList is not present in the groupByClause collection, an exception is thrown.</param> /// <param name="transactionToUse">The transaction object to use. Can be null. If specified, the connection object of the transaction is used to fill the TypedView, which avoids deadlocks on SqlServer.</param> /// <param name="pageNumber">The page number to retrieve.</param> /// <param name="pageSize">The page size of the page to retrieve.</param> /// <returns>true if succeeded, false otherwise</returns> public bool GetMultiAsDataTable(IEntityFields fieldsToReturn, DataTable tableToFill, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IPredicate selectFilter, IRelationCollection relations, bool allowDuplicates, IGroupByCollection groupByClause, ITransaction transactionToUse, int pageNumber, int pageSize) { return(base.PerformGetMultiAsDataTableAction(fieldsToReturn, tableToFill, maxNumberOfItemsToReturn, sortClauses, selectFilter, relations, allowDuplicates, groupByClause, transactionToUse, pageNumber, pageSize)); }
/// <summary> /// Creates a new Select Query which is ready to use, based on the specified select list and the specified set of relations. /// If selectFilter is set to null, all rows are selected. /// </summary> /// <param name="selectList">list of IEntityFieldCore objects to select</param> /// <param name="fieldsPersistenceInfo">Array of IFieldPersistenceInfo objects to use to build the select query</param> /// <param name="query">The query to fill.</param> /// <param name="selectFilter">A complete IPredicate implementing object which contains the filter for the rows to select. When set to null, no /// filtering is done, and all rows are returned.</param> /// <param name="maxNumberOfItemsToReturn">The maximum number of items to return with this retrieval query. /// If the used Dynamic Query Engine supports it, 'TOP' is used to limit the amount of rows to return. /// When set to 0, no limitations are specified.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param> /// <param name="relationsToWalk">list of EntityRelation objects, which will be used to formulate a FROM clause with INNER JOINs.</param> /// <param name="allowDuplicates">Flag which forces the inclusion of DISTINCT if set to true. If the resultset contains fields of type ntext, text or image, no duplicate filtering /// is done.</param> /// <param name="groupByClause">The list of fields to group by on. When not specified or an empty collection is specified, no group by clause /// is added to the query. A check is performed for each field in the selectList. If a field in the selectList is not present in the groupByClause /// collection, an exception is thrown.</param> /// <param name="relationsSpecified">flag to signal if relations are specified, this is a result of a check. This routine should /// simply assume the value of this flag is correct.</param> /// <param name="sortClausesSpecified">flag to signal if sortClauses are specified, this is a result of a check. This routine should /// simply assume the value of this flag is correct.</param> /// <exception cref="System.ArgumentNullException">When selectList is null or fieldsPersistenceInfo is null</exception> /// <exception cref="System.ArgumentException">When selectList contains no EntityFieldCore instances or fieldsPersistenceInfo is empty.</exception> protected override void CreateSelectDQ(IEntityFieldCore[] selectList, IFieldPersistenceInfo[] fieldsPersistenceInfo, IRetrievalQuery query, IPredicate selectFilter, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IRelationCollection relationsToWalk, bool allowDuplicates, IGroupByCollection groupByClause, bool relationsSpecified, bool sortClausesSpecified) { TraceHelper.WriteLineIf(Switch.TraceInfo, "CreateSelectDQ", "Method Enter"); QueryFragments fragments = new QueryFragments(); fragments.AddFragment("SELECT"); StringPlaceHolder distinctPlaceholder = fragments.AddPlaceHolder(); StringPlaceHolder topPlaceholder = fragments.AddPlaceHolder(); DelimitedStringList projection = fragments.AddCommaFragmentList(false); UniqueList <string> fieldNamesInSelectList; bool distinctViolatingTypesFound; bool pkFieldSeen; AppendResultsetFields(selectList, fieldsPersistenceInfo, relationsToWalk, projection, sortClausesSpecified, allowDuplicates, true, new UniqueList <string>(), query, out fieldNamesInSelectList, out distinctViolatingTypesFound, out pkFieldSeen); bool resultsCouldContainDuplicates = this.DetermineIfDuplicatesWillOccur(relationsToWalk); bool distinctEmitted = this.HandleDistinctEmit(sortClauses, allowDuplicates, sortClausesSpecified, query, distinctPlaceholder, distinctViolatingTypesFound, (pkFieldSeen && !resultsCouldContainDuplicates), fieldNamesInSelectList); bool groupByClauseSpecified = ((groupByClause != null) && (groupByClause.Count > 0)); if (maxNumberOfItemsToReturn > 0) { // row limits are emitted always, unless duplicates are required but DISTINCT wasn't emitable. If not emitable, switch to client-side row limitation if (distinctEmitted || !resultsCouldContainDuplicates || groupByClauseSpecified || allowDuplicates) { topPlaceholder.SetFormatted("TOP {0}", maxNumberOfItemsToReturn); } else { query.RequiresClientSideLimitation = true; query.ManualRowsToTake = (int)maxNumberOfItemsToReturn; } } if (relationsSpecified) { fragments.AddFormatted("FROM {0}", relationsToWalk.ToQueryText()); query.AddParameters(((RelationCollection)relationsToWalk).CustomFilterParameters); } else { var persistenceInfoToUse = fieldsPersistenceInfo.FirstOrDefault(p => p != null); if ((persistenceInfoToUse != null) && (persistenceInfoToUse.SourceObjectName.Length > 0)) { fragments.AddFormatted(" FROM {0}", this.Creator.CreateObjectName(persistenceInfoToUse)); string targetAlias = this.DetermineTargetAlias(selectList[0], relationsToWalk); if (targetAlias.Length > 0) { fragments.AddFormatted(" {0}", this.Creator.CreateValidAlias(targetAlias)); } } } AppendWhereClause(selectFilter, fragments, query); AppendGroupByClause(groupByClause, fragments, query); AppendOrderByClause(sortClauses, fragments, query); query.SetCommandText(MakeParametersAnonymous(fragments.ToString(), query.Parameters)); TraceHelper.WriteIf(Switch.TraceVerbose, query, "Generated Sql query"); TraceHelper.WriteLineIf(Switch.TraceInfo, "CreateSelectDQ", "Method Exit"); }
/// <summary> /// Creates a new Update Query object which is ready to use. Only 'changed' EntityFieldCore are included in the update query. /// Primary Key fields are never updated. /// </summary> /// <param name="fields">Array of EntityFieldCore objects to use to build the insert query</param> /// <param name="fieldsPersistenceInfo">Array of IFieldPersistenceInfo objects to use to build the update query</param> /// <param name="query">The query object to fill.</param> /// <param name="updateFilter">A complete IPredicate implementing object which contains the filter for the rows to update</param> /// <param name="relationsToWalk">list of EntityRelation objects, which will be used to formulate a FROM clause with INNER JOINs.</param> /// <exception cref="System.ArgumentNullException">When fields is null or when updateFilter is null or /// when relationsToWalk is null or when fieldsPersistence is null</exception> /// <exception cref="System.ArgumentException">When fields contains no EntityFieldCore instances or fieldsPersistenceInfo is empty.</exception> protected override void CreateSingleTargetUpdateDQ(IEntityFieldCore[] fields, IFieldPersistenceInfo[] fieldsPersistenceInfo, IActionQuery query, IPredicate updateFilter, IRelationCollection relationsToWalk) { this.CreateSingleTargetUpdateDQUsingFromClause(fields, fieldsPersistenceInfo, query, updateFilter, relationsToWalk); // ASA doesn't support named parameters, anonymize them MakeParametersAnonymous(query.Command); }
/// <summary> Retrieves Entity rows in a datatable which match the specified filter. It will always create a new connection to the database.</summary> /// <param name="selectFilter">A predicate or predicate expression which should be used as filter for the entities to retrieve.</param> /// <param name="maxNumberOfItemsToReturn"> The maximum number of items to return with this retrieval query.</param> /// <param name="sortClauses">The order by specifications for the sorting of the resultset. When not specified, no sorting is applied.</param> /// <param name="relations">The set of relations to walk to construct to total query.</param> /// <param name="pageNumber">The page number to retrieve.</param> /// <param name="pageSize">The page size of the page to retrieve.</param> /// <returns>DataTable with the rows requested.</returns> public static DataTable GetMultiAsDataTable(IPredicate selectFilter, long maxNumberOfItemsToReturn, ISortExpression sortClauses, IRelationCollection relations, int pageNumber, int pageSize) { ServiceLocationAssetTypeChangeLogDAO dao = DAOFactory.CreateServiceLocationAssetTypeChangeLogDAO(); return(dao.GetMultiAsDataTable(maxNumberOfItemsToReturn, sortClauses, selectFilter, relations, pageNumber, pageSize)); }
public override void AuditDirectUpdateOfEntities(IEntityCore entity, IPredicate filter, IRelationCollection relations, int numberOfEntitiesUpdated) { if (EnableDataAccessAuditing && EnableDataAccessAuditingUpdate && IsEntityAuditable(entity)) { if (!IsAuditActionValid(entity)) { return; } IAuditInfoEntity auditInfo = CreateAuditInfoEntity(entity, MonoSoftware.LLBLGen.AuditType.DirectUpdateOfEntities); if (auditInfo == null) { return; } auditInfo.ActionDataLog.Messages.Add(String.Format("{0} Entities of type {1} updated.", numberOfEntitiesUpdated, entity.LLBLGenProEntityName)); if (EnableIntensiveAuditing) { auditInfo.ActionDataLog.Data = BinarySerializer.Serialize(new Tuple <IPredicate, IRelationCollection>(filter, relations)); } _auditInfoEntities.Add(entity.ObjectID, auditInfo); } //base.AuditDirectUpdateOfEntities(entity, filter, relations, numberOfEntitiesUpdated); }
/// <summary>Gets a scalar value, calculated with the aggregate and expression specified. the field index specified is the field the expression and aggregate are applied on.</summary> /// <param name="fieldIndex">Field index of field to which to apply the aggregate function and expression</param> /// <param name="expressionToExecute">The expression to execute. Can be null</param> /// <param name="aggregateToApply">Aggregate function to apply. </param> /// <param name="filter">The filter to apply to retrieve the scalar</param> /// <param name="relations">The relations to walk</param> /// <param name="groupByClause">The groupby clause to apply to retrieve the scalar</param> /// <returns>the scalar value requested</returns> public virtual object GetScalar(CustomerDemographicFieldIndex fieldIndex, IExpression expressionToExecute, AggregateFunction aggregateToApply, IPredicate filter, IRelationCollection relations, IGroupByCollection groupByClause) { EntityFields fields = new EntityFields(1); fields[0] = EntityFieldFactory.Create(fieldIndex); if(expressionToExecute != null) { fields[0].ExpressionToApply = expressionToExecute; } if(aggregateToApply != AggregateFunction.None) { fields[0].AggregateFunctionToApply = aggregateToApply; } return DAOFactory.CreateCustomerDemographicDAO().GetScalar(fields, this.Transaction, filter, relations, groupByClause); }