public T ExecuteScalar <T>(QueryDescription query, ObjectBinder objectBinder) { var key = CacheKey.Create(new HiveQueryCacheKey(query)); Func <T> execution = () => PerformExecuteScalar <T>(query, objectBinder); var cacheCheck = ContextCacheAvailable() ? HiveContext.GenerationScopedCache.GetOrCreate(key, execution) : null; //var performExecute = PerformExecuteScalar<T>(query, objectBinder); var performExecute = cacheCheck != null ? cacheCheck.Value.Item : execution.Invoke(); if ((!typeof(T).IsValueType && performExecute == null) || performExecute.Equals(default(T))) { return(default(T)); } if (typeof(IReferenceByHiveId).IsAssignableFrom(typeof(T))) { ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, (IReferenceByHiveId)performExecute); } if (typeof(IRelatableEntity).IsAssignableFrom(typeof(T))) { this.SetRelationProxyLazyLoadDelegate((IRelatableEntity)performExecute); } return(performExecute); }
public IEnumerable <T> ExecuteMany <T>(QueryDescription query, ObjectBinder objectBinder) { var key = CacheKey.Create(new HiveQueryCacheKey(query)); Func <List <T> > execution = () => { var executeItems = PerformExecuteMany <T>(query, objectBinder) ?? Enumerable.Empty <T>(); return(executeItems.ToList()); // Ensure the executed sequence is cached }; var cacheCheck = ContextCacheAvailable() ? HiveContext.GenerationScopedCache.GetOrCreate(key, execution) : null; var performExecute = cacheCheck != null ? cacheCheck.Value.Item : execution.Invoke(); //var performExecute = PerformExecuteMany<T>(query, objectBinder) ?? Enumerable.Empty<T>(); var items = performExecute .ForAllThatAre <T, IReferenceByHiveId>(entity => ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, entity)) .ForAllThatAre <T, IRelatableEntity>(entity => this.SetRelationProxyLazyLoadDelegate(entity)); if (query.From.RequiredEntityIds.Any() && !query.SortClauses.Any()) { // Return in same order as supplied ids return(query.From.RequiredEntityIds.Select(x => items.OfType <IReferenceByHiveId>().FirstOrDefault(y => y.Id.Value == x.Value)).WhereNotNull().OfType <T>()); } return(items); }
protected AbstractSchemaRepository(ProviderMetadata providerMetadata, AbstractRevisionRepository <EntitySchema> revisions, IProviderTransaction providerTransaction, IFrameworkContext frameworkContext) : base(providerMetadata, revisions, frameworkContext) { CanWrite = true; Transaction = providerTransaction; Revisions = revisions; Revisions.RelatedEntitiesLoader = x => ProviderRepositoryHelper.CreateRelationLazyLoadDelegate(this, x).Invoke(x); }
public IEnumerable <Revision <TEntity> > GetAll <TEntity>(HiveId entityId, RevisionStatusType revisionStatusType = null) where TEntity : class, T { var performGetAll = PerformGetAll <TEntity>(entityId, revisionStatusType); return(performGetAll == null && !performGetAll.Any() ? Enumerable.Empty <Revision <TEntity> >() : performGetAll.Select(x => ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, this.SetRelationProxyLazyLoadDelegate(x)))); }
private void OnAddOrUpdateComplete <TEntity>(Revision <TEntity> revision) where TEntity : class, T { ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, revision.MetaData); ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, revision.Item); this.SetRelationProxyLazyLoadDelegate(revision); //RevisionDataAddedOrUpdated.Add(revision.MetaData); //EntityDataAddedOrUpdated.Add(revision.Item); RevisionsAddedOrUdpated.Add(revision); }
public IEnumerable <T> GetAll <T>() where T : TypedEntity { var performGetAll = PerformGetAll <T>() ?? Enumerable.Empty <T>(); return(performGetAll.Select(x => { x.EntitySchema = Schemas.Get <EntitySchema>(x.EntitySchema.Id) ?? x.EntitySchema; return ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, this.SetRelationProxyLazyLoadDelegate(x)); })); }
public IEnumerable <T> Get <T>(bool allOrNothing, params HiveId[] ids) where T : TypedEntity { if (!ids.Any()) { return(Enumerable.Empty <T>()); } var performGet = PerformGet <T>(allOrNothing, ids) ?? Enumerable.Empty <T>(); return(performGet.WhereNotNull().Select(x => { x.EntitySchema = Schemas.GetComposite <EntitySchema>(x.EntitySchema.Id); return ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, this.SetRelationProxyLazyLoadDelegate(x)); })); }
public IEnumerable <TEntity> GetAll <TEntity>() where TEntity : AbstractSchemaPart { var performGetAll = PerformGetAll <TEntity>() ?? Enumerable.Empty <TEntity>(); // Enumerate the sequence once var all = performGetAll.ToArray(); // Operate on a subset of the same array that we will then return all .WhereNotNull() .Where(x => typeof(IRelatableEntity).IsAssignableFrom(x.GetType())).ToArray() .ForEach(x => this.SetRelationProxyLazyLoadDelegate((IRelatableEntity)x)); // Return the total set manipulating their id beforehand return(all.Select(x => ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, x))); }
protected AbstractEntityRepository(ProviderMetadata providerMetadata, IProviderTransaction providerTransaction, AbstractRevisionRepository <TypedEntity> revisions, AbstractSchemaRepository schemas, IFrameworkContext frameworkContext) : base(providerMetadata, revisions, schemas, frameworkContext) { EntitiesDeleted = new HashSet <HiveId>(); Transaction = providerTransaction; Revisions = revisions; Schemas = schemas; Revisions.RelatedEntitiesLoader = x => ProviderRepositoryHelper.CreateRelationLazyLoadDelegate(this, x).Invoke(x); Revisions.RegisterRelatedEntities = relation => { if (this.CanWriteRelations) { this.AddRelation(relation); } }; }
public IEnumerable <T> Get <T>(bool allOrNothing, params HiveId[] ids) where T : AbstractSchemaPart { if (!ids.Any()) { return(Enumerable.Empty <T>()); } var performGet = PerformGet <T>(allOrNothing, ids) ?? Enumerable.Empty <T>(); // Enumerate the sequence once var all = performGet.ToArray(); // Operate on a subset of the same array that we will then return all .Where(x => typeof(IRelatableEntity).IsAssignableFrom(x.GetType())).ToArray() .ForEach(x => this.SetRelationProxyLazyLoadDelegate((IRelatableEntity)x)); // Return the total set manipulating their id beforehand return(all.Select(x => ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, x))); }
private void OnAddOrUpdateComplete(AbstractSchemaPart entity) { this.SetRelationProxyLazyLoadDelegate(entity as IRelatableEntity); ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, entity); EntitiesAddedOrUpdated.Add(entity); }
public IEnumerable <Revision <TEntity> > GetLatestRevisions <TEntity>(bool allOrNothing, RevisionStatusType revisionStatusType = null, params HiveId[] entityIds) where TEntity : class, T { var performGet = PerformGetLatestRevisions <TEntity>(allOrNothing, revisionStatusType, entityIds) ?? Enumerable.Empty <Revision <TEntity> >(); return(performGet.Select(x => ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, this.SetRelationProxyLazyLoadDelegate(x)))); }
public Revision <TEntity> GetLatestRevision <TEntity>(HiveId entityId, RevisionStatusType revisionStatusType = null) where TEntity : class, T { var performGet = PerformGetLatestRevision <TEntity>(entityId, revisionStatusType); return(ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, this.SetRelationProxyLazyLoadDelegate(performGet))); }
public Revision <TEntity> Get <TEntity>(HiveId entityId, HiveId revisionId) where TEntity : class, T { return(ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, this.SetRelationProxyLazyLoadDelegate(PerformGet <TEntity>(entityId, revisionId)))); }
protected void OnAddOrUpdateComplete(TypedEntity entity) { this.SetRelationProxyLazyLoadDelegate(entity); ProviderRepositoryHelper.SetProviderAliasOnId(ProviderMetadata, entity); EntitiesAddedOrUpdated.Add(entity); }