public IReadOnlyList <AttributeHolder> Find(SlicedEntityMetadata slicedEntityMetadata, PaginatedSearchRequestDto searchDto, IDictionary <string, ApplicationCompositionSchema> compositionSchemas) { var list = _entityRepository.Get(slicedEntityMetadata, searchDto); return(list); }
public AttributeHolder FindById(ApplicationSchemaDefinition schema, SlicedEntityMetadata entityMetadata, string id) { var mainEntity = _entityRepository.Get(entityMetadata, id); if (mainEntity == null) { return(null); } return(mainEntity); }
internal void BuildProjection(SlicedEntityMetadata metadata) { var columns = metadata.Attributes(EntityMetadata.AttributesMode.NoCollections); foreach (var column in columns) { AppendProjectionField(new ProjectionField { Name = column.Name, Alias = column.Name }); } }
private EntityRepository.SearchEntityResult FetchMore(PaginatedSearchRequestDto dto, DateTime lastMonth, SlicedEntityMetadata slicedMetadata, long?lowerRowstamp, Boolean initofBatch) { dto.AppendSearchEntry("status", "!=DECOMMISSIONED"); dto.AppendSearchEntry("changedate", ">=" + lastMonth.ToShortDateString()); if (initofBatch) { dto.AppendSearchEntry("rowstamp", ">" + lowerRowstamp); } else { dto.AppendSearchEntry("rowstamp", ">=" + lowerRowstamp); } dto.SearchSort = "rowstamp asc"; dto.QueryAlias = "R0042"; var searchEntityResult = _entityRepository.GetAsRawDictionary(slicedMetadata, dto, false); return(searchEntityResult); }
private BindedEntityQuery HandleUnion(SlicedEntityMetadata slicedEntityMetadata, InternalQueryRequest queryParameter, string queryString, QueryCacheKey.QueryMode queryMode, IEnumerable <KeyValuePair <string, object> > parameters) { var queryModeToPropagate = queryMode == QueryCacheKey.QueryMode.Count ? QueryCacheKey.QueryMode.Count : QueryCacheKey.QueryMode.Union; var unionQuery = TemplateQueryBuild(slicedEntityMetadata.UnionSchema, new InternalQueryRequest() { SearchDTO = queryParameter.SearchDTO.unionDTO }, queryModeToPropagate); queryString += (" union all " + unionQuery.Sql + " "); if (queryMode == QueryCacheKey.QueryMode.Count) { queryString = "select sum(cnt) from (" + queryString + ")"; return(new BindedEntityQuery(queryString, parameters.Union(unionQuery.Parameters))); } //for unions, we need to do the order by in the end queryString += QuerySearchSortBuilder.BuildSearchSort(slicedEntityMetadata, queryParameter.SearchDTO); return(new BindedEntityQuery(queryString, parameters.Union(unionQuery.Parameters))); }
public Dictionary <string, EntityRepository.SearchEntityResult> ResolveCollections(SlicedEntityMetadata entityMetadata, IDictionary <string, ApplicationCompositionSchema> compositionSchemas, IReadOnlyList <AttributeHolder> entitiesList, PaginatedSearchRequestDto paginatedSearch = null) { if (!compositionSchemas.Any()) { return(new Dictionary <string, EntityRepository.SearchEntityResult>()); } var before = Stopwatch.StartNew(); _log.DebugFormat("Init Collection Resolving for {0} Collections", String.Join(",", compositionSchemas.Keys)); var collectionAssociations = new List <EntityAssociation>(); foreach (var entityListAssociation in entityMetadata.ListAssociations()) { if (compositionSchemas.Keys.Contains(entityListAssociation.Qualifier)) { collectionAssociations.Add(entityListAssociation); } } var results = new Dictionary <string, EntityRepository.SearchEntityResult>(); var tasks = new Task[collectionAssociations.Count]; var i = 0; var ctx = ContextLookuper.LookupContext(); foreach (var collectionAssociation in collectionAssociations) { var association = collectionAssociation; var shouldPaginate = ShouldPaginate(compositionSchemas[association.Qualifier], paginatedSearch) && paginatedSearch != null; var perThreadPaginatedSearch = shouldPaginate ? (PaginatedSearchRequestDto)paginatedSearch.ShallowCopy() : null; //this will avoid that one thread impacts any other var perThreadContext = ctx.ShallowCopy(); tasks[i++] = Task.Factory.NewThread(() => FetchAsync(entityMetadata, association, compositionSchemas, entitiesList, perThreadContext, results, perThreadPaginatedSearch)); } Task.WaitAll(tasks); _log.Debug(LoggingUtil.BaseDurationMessageFormat(before, "Finish Collection Resolving for {0} Collections", String.Join(",", compositionSchemas.Keys))); return(results); }
public Dictionary <string, EntityRepository.SearchEntityResult> ResolveCollections(SlicedEntityMetadata entityMetadata, IDictionary <string, ApplicationCompositionSchema> compositionSchemas, AttributeHolder mainEntity, PaginatedSearchRequestDto paginatedSearch = null) { return(ResolveCollections(entityMetadata, compositionSchemas, new List <AttributeHolder> { mainEntity }, paginatedSearch)); }
private void FetchAsync(SlicedEntityMetadata entityMetadata, EntityAssociation collectionAssociation, IDictionary <string, ApplicationCompositionSchema> compositionSchemas, IEnumerable <AttributeHolder> entitiesList, ContextHolder ctx, Dictionary <string, EntityRepository.SearchEntityResult> results, PaginatedSearchRequestDto paginatedSearch) { Quartz.Util.LogicalThreadContext.SetData("context", ctx); var lookupAttributes = collectionAssociation.Attributes; var collectionEntityMetadata = MetadataProvider.Entity(collectionAssociation.To); var targetCollectionAttribute = EntityUtil.GetRelationshipName(collectionAssociation.Qualifier); var applicationCompositionSchema = compositionSchemas[collectionAssociation.Qualifier] as ApplicationCompositionCollectionSchema; if (applicationCompositionSchema == null) { throw ExceptionUtil.InvalidOperation("collection schema {0} not found", collectionAssociation.Qualifier); } var lookupattributes = lookupAttributes as EntityAssociationAttribute[] ?? lookupAttributes.ToArray(); var attributeHolders = entitiesList as AttributeHolder[] ?? entitiesList.ToArray(); var matchingResultWrapper = new CollectionMatchingResultWrapper(); var searchRequestDto = BuildSearchRequestDto(applicationCompositionSchema, lookupattributes, matchingResultWrapper, attributeHolders, collectionEntityMetadata, paginatedSearch); searchRequestDto.QueryAlias = collectionAssociation.To; var firstAttributeHolder = attributeHolders.First(); if (applicationCompositionSchema.PrefilterFunction != null) { var dataSet = DataSetProvider.GetInstance().LookupDataSet(entityMetadata.ApplicationName); //we will call the function passing the first entry, altough this method could have been invoked for a list of items (printing) //TODO: think about it var preFilterParam = new CompositionPreFilterFunctionParameters(entityMetadata.AppSchema, searchRequestDto, firstAttributeHolder, applicationCompositionSchema); searchRequestDto = PrefilterInvoker.ApplyPreFilterFunction(dataSet, preFilterParam, applicationCompositionSchema.PrefilterFunction); } EntityRepository.SearchEntityResult queryResult = null; if (paginatedSearch == null) { //if there´s no pagination needed we can just do one thread-query queryResult = EntityRepository.GetAsRawDictionary(collectionEntityMetadata, searchRequestDto); } else { var tasks = new Task[2]; tasks[0] = Task.Factory.NewThread(() => { queryResult = EntityRepository.GetAsRawDictionary(collectionEntityMetadata, searchRequestDto); }); // one thread to count results for paginations tasks[1] = Task.Factory.NewThread(() => { paginatedSearch.TotalCount = EntityRepository.Count(collectionEntityMetadata, searchRequestDto); }); Task.WaitAll(tasks); // add paginationData to result // creating a new pagination data in order to have everything calculated correctly queryResult.PaginationData = new PaginatedSearchRequestDto( paginatedSearch.TotalCount, paginatedSearch.PageNumber, paginatedSearch.PageSize, paginatedSearch.SearchValues, paginatedSearch.PaginationOptions ); } // one thread to fetch results results.Add(collectionAssociation.Qualifier, queryResult); if (attributeHolders.Length == 1) { //default scenario, we have just one entity here firstAttributeHolder.Attributes.Add(targetCollectionAttribute, queryResult.ResultList); return; } MatchResults(queryResult, matchingResultWrapper, targetCollectionAttribute); }
public IReadOnlyList <AttributeHolder> Find(SlicedEntityMetadata slicedEntityMetadata, PaginatedSearchRequestDto searchDto) { return(Find(slicedEntityMetadata, searchDto, null)); }
public IList <IEnumerable <KeyValuePair <string, object> > > GetSynchronizationData(SlicedEntityMetadata entityMetadata, Rowstamps rowstamps) { var query = new EntityQueryBuilder().AllRowsForSync(entityMetadata, rowstamps); //TODO: hack to avoid garbage data and limit size of list queries. var sql = query.Sql; var queryResult = GetDao(entityMetadata).FindByNativeQuery(sql, query.Parameters); var rows = queryResult.Cast <IEnumerable <KeyValuePair <string, object> > >(); return(rows as IList <IEnumerable <KeyValuePair <string, object> > > ?? rows.ToList()); }