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());
}
