public void Prefetch()
{
var c2PrefetchPolicy = new PrefetchPolicyBuilder()
.WithRule(C2.Meta.C3Many2Manies)
.Build();
var c1PrefetchPolicy = new PrefetchPolicyBuilder()
.WithRule(C1.Meta.C1C2many2manies, c2PrefetchPolicy)
.Build();
foreach (var init in this.Inits)
{
init();
this.Populate();
this.Session.Commit();
var c1s = this.Session.Extent <C1>().ToArray();
this.Session.Prefetch(c1PrefetchPolicy, c1s);
foreach (C2 c2 in this.Session.Extent <C2>())
{
c2.Strategy.Delete();
foreach (C3 c3 in this.Session.Extent <C3>())
{
c3.Strategy.Delete();
c1s = this.Session.Extent <C1>().ToArray();
this.Session.Prefetch(c1PrefetchPolicy, c1s);
}
}
}
}
public SyncResponse Build()
{
var objects = this.session.Instantiate(this.syncRequest.Objects);
// Prefetch
var objectByClass = objects.GroupBy(v => v.Strategy.Class, v => v);
foreach (var groupBy in objectByClass)
{
var prefetchClass = (Class)groupBy.Key;
var prefetchObjects = groupBy.ToArray();
var prefetchPolicyBuilder = new PrefetchPolicyBuilder();
prefetchPolicyBuilder.WithGroupRules(prefetchClass, this.@group);
prefetchPolicyBuilder.WithSecurityRules();
var prefetcher = prefetchPolicyBuilder.Build();
this.session.Prefetch(prefetcher, prefetchObjects);
}
return(new SyncResponse
{
UserSecurityHash = this.user.SecurityHash(),
Objects = objects.Select(x => new SyncResponseObject
{
I = x.Id.ToString(),
V = x.Strategy.ObjectVersion.ToString(),
T = x.Strategy.Class.Name,
Roles = this.GetRoles(x),
Methods = this.GetMethods(x),
}).ToArray()
});
}
public PrefetchPolicy this[IClass @class] // Indexer declaration
{
get
{
if (!this.prefetchPolicyByClass.TryGetValue(@class, out var prefetchPolicy))
{
var prefetchPolicyBuilder = new PrefetchPolicyBuilder();
foreach (var roleType in @class.RoleTypes)
{
prefetchPolicyBuilder.WithRule(roleType);
}
foreach (var associationType in @class.AssociationTypes)
{
prefetchPolicyBuilder.WithRule(associationType);
}
prefetchPolicy = prefetchPolicyBuilder.Build();
this.prefetchPolicyByClass[@class] = prefetchPolicy;
}
return(prefetchPolicy);
}
}
public void PrefetchOneClass()
{
var c2Prefetcher = new PrefetchPolicyBuilder().WithRule(C1.Meta.C1AllorsString).Build();
var c1Prefetcher =
new PrefetchPolicyBuilder().WithRule(C1.Meta.C1C2one2one, c2Prefetcher)
.WithRule(C1.Meta.C1AllorsString)
.Build();
foreach (var init in this.Inits)
{
init();
this.Populate();
var connection = (DebugConnection)this.ConnectionFactory.Create(this.Database);
using (var session = this.Database.CreateSession(connection))
{
var extent = session.Extent <C1>();
session.Prefetch(c1Prefetcher, extent);
connection.Commands.Count.ShouldEqual(5);
connection.Executions.Count().ShouldEqual(6);
var stringBuilder = new StringBuilder();
foreach (C1 c1 in extent)
{
stringBuilder.Append(c1.C1AllorsString);
var c2 = c1.C1C2one2one;
stringBuilder.Append(c2?.C2AllorsString);
}
connection.Commands.Count.ShouldEqual(5);
connection.Executions.Count().ShouldEqual(6);
}
this.Cache.Invalidate();
connection = (DebugConnection)this.ConnectionFactory.Create(this.Database);
using (var session = this.Database.CreateSession(connection))
{
var extent = session.Extent <C1>();
session.Prefetch(c1Prefetcher, extent);
var stringBuilder = new StringBuilder();
foreach (C1 c1 in extent)
{
stringBuilder.Append(c1.C1AllorsString);
var c2 = c1.C1C2one2one;
stringBuilder.Append(c2?.C2AllorsString);
}
connection.Commands.Count.ShouldEqual(5);
connection.Executions.Count().ShouldEqual(6);
}
}
}
public PrefetchPolicy BuildPrefetechPolicy()
{
var prefetchPolicyBuilder = new PrefetchPolicyBuilder();
foreach (var node in this.Nodes)
{
node.BuildPrefetchPolicy(prefetchPolicyBuilder);
}
return(prefetchPolicyBuilder.Build());
}
public static PrefetchPolicy BuildPrefetchPolicy(this Node[] treeNodes)
{
var prefetchPolicyBuilder = new PrefetchPolicyBuilder();
foreach (var node in treeNodes)
{
node.BuildPrefetchPolicy(prefetchPolicyBuilder);
}
return(prefetchPolicyBuilder.Build());
}
public void Prefetch()
{
var c1Prefetcher = new PrefetchPolicyBuilder().WithRule(C1.Meta.C1AllorsString).Build();
foreach (var init in this.Inits)
{
init();
this.Populate();
var connection = (DebugConnection)this.ConnectionFactory.Create(this.Database);
using (var session = this.Database.CreateSession(connection))
{
var extent = session.Extent <C1>();
session.Prefetch(c1Prefetcher, extent);
Assert.Equal(3, connection.Commands.Count);
Assert.Equal(3, connection.Executions.Count());
var stringBuilder = new StringBuilder();
foreach (C1 c1 in extent)
{
stringBuilder.Append(c1.C1AllorsString);
}
Assert.Equal(3, connection.Commands.Count);
Assert.Equal(3, connection.Executions.Count());
}
this.InvalidateCache();
connection = (DebugConnection)this.ConnectionFactory.Create(this.Database);
using (var session = this.Database.CreateSession(connection))
{
var extent = session.Extent <C1>();
session.Prefetch(c1Prefetcher, extent);
var stringBuilder = new StringBuilder();
foreach (C1 c1 in extent)
{
stringBuilder.Append(c1.C1AllorsString);
}
Assert.Equal(3, connection.Commands.Count);
Assert.Equal(3, connection.Executions.Count());
}
}
}
public void BuildPrefetchPolicy(PrefetchPolicyBuilder prefetchPolicyBuilder)
{
if (this.Nodes == null || this.Nodes.Length == 0)
{
prefetchPolicyBuilder.WithRule(this.PropertyType);
}
else
{
var nestedPrefetchPolicyBuilder = new PrefetchPolicyBuilder();
foreach (var node in this.Nodes)
{
node.BuildPrefetchPolicy(nestedPrefetchPolicyBuilder);
}
var nestedPrefetchPolicy = nestedPrefetchPolicyBuilder.Build();
prefetchPolicyBuilder.WithRule(this.PropertyType, nestedPrefetchPolicy);
}
}
public void BuildPrefetchPolicy(PrefetchPolicyBuilder prefetchPolicyBuilder)
{
if (this.Nodes.Count == 0)
{
prefetchPolicyBuilder.WithRule(this.RoleType);
}
else
{
var nestedPrefetchPolicyBuilder = new PrefetchPolicyBuilder();
foreach (var node in this.Nodes)
{
node.BuildPrefetchPolicy(nestedPrefetchPolicyBuilder);
}
var nestedPrefetchPolicy = nestedPrefetchPolicyBuilder.Build();
prefetchPolicyBuilder.WithRule(this.RoleType, nestedPrefetchPolicy);
}
}
public void PrefetchCompositesRole()
{
var database = this.CreateDatabase();
database.Init();
using (var session = database.CreateSession())
{
var c1a = C1.Create(session);
var c1b = C1.Create(session);
var c2a = C2.Create(session);
var c2b = C2.Create(session);
var c2c = C2.Create(session);
c1a.AddC1C2one2many(c2a);
c1a.AddC1C2one2many(c2b);
session.Commit();
c1a.RemoveC1C1one2manies();
c1a.AddC1C2one2many(c2c);
var extent = session.Extent <C1>();
var array = extent.ToArray();
var nestedPrefetchPolicyBuilder = new PrefetchPolicyBuilder();
nestedPrefetchPolicyBuilder.WithRule(M.C2.C2C2one2manies);
var nestedPrefetchPolicy = nestedPrefetchPolicyBuilder.Build();
var prefetchPolicyBuilder = new PrefetchPolicyBuilder();
prefetchPolicyBuilder.WithRule(M.C1.C1C2one2manies, nestedPrefetchPolicy);
var prefetchPolicy = prefetchPolicyBuilder.Build();
session.Prefetch(prefetchPolicy, new[] { c1a, c1b });
var result = c1a.C1C2one2manies;
session.Rollback();
Assert.Equal(2, c1a.C1C2one2manies.Count);
Assert.Contains(c2a, c1a.C1C2one2manies.ToArray());
Assert.Contains(c2b, c1a.C1C2one2manies.ToArray());
}
}
public static void Register()
{
// Initialize meta population
var metaPopulation = MetaPopulation.Instance;
if (IsProduction)
{
var accessControlPrefetch = new PrefetchPolicyBuilder()
.WithRule(M.AccessControl.EffectiveUsers)
.WithRule(M.AccessControl.EffectivePermissions)
.Build();
var securityTokenPrefetch = new PrefetchPolicyBuilder()
.WithRule(M.SecurityToken.AccessControls, accessControlPrefetch)
.Build();
using (var session = Config.Default.CreateSession())
{
var securityTokens = new SecurityTokens(session).Extent();
session.Prefetch(securityTokenPrefetch, securityTokens);
}
}
}
public void PrefetchCompositeRole()
{
var database = this.CreateDatabase();
database.Init();
using (var session = database.CreateSession())
{
var c1a = C1.Create(session);
var c1b = C1.Create(session);
var c2a = C2.Create(session);
var c2b = C2.Create(session);
session.Commit();
c1a.C1C2many2one = c2a;
var extent = session.Extent <C1>();
var array = extent.ToArray();
var nestedPrefetchPolicyBuilder = new PrefetchPolicyBuilder();
nestedPrefetchPolicyBuilder.WithRule(M.C2.C2C2one2manies);
var nestedPrefetchPolicy = nestedPrefetchPolicyBuilder.Build();
var prefetchPolicyBuilder = new PrefetchPolicyBuilder();
prefetchPolicyBuilder.WithRule(M.C1.C1C2many2one, nestedPrefetchPolicy);
var prefetchPolicy = prefetchPolicyBuilder.Build();
session.Prefetch(prefetchPolicy, new[] { c1a, c1b });
var result = c1a.C1C2many2one;
session.Rollback();
Assert.False(c1a.ExistC1C2many2one);
}
}
public SyncResponse Build()
{
var objects = this.session.Instantiate(this.syncRequest.Objects);
// Prefetch
var objectByClass = objects.GroupBy(v => v.Strategy.Class, v => v);
foreach (var groupBy in objectByClass)
{
var prefetchClass = (Class)groupBy.Key;
var prefetchObjects = groupBy.ToArray();
var prefetchPolicyBuilder = new PrefetchPolicyBuilder();
prefetchPolicyBuilder.WithWorkspaceRules(prefetchClass);
prefetchPolicyBuilder.WithSecurityRules(prefetchClass);
var prefetcher = prefetchPolicyBuilder.Build();
this.session.Prefetch(prefetcher, prefetchObjects);
}
SyncResponseRole CreateSyncResponseRole(IObject @object, IRoleType roleType)
{
var syncResponseRole = new SyncResponseRole {
T = roleType.IdAsString
};
if (roleType.ObjectType.IsUnit)
{
syncResponseRole.V = UnitConvert.ToString(@object.Strategy.GetUnitRole(roleType.RelationType));
}
else if (roleType.IsOne)
{
syncResponseRole.V = @object.Strategy.GetCompositeRole(roleType.RelationType)?.Id.ToString();
}
else
{
var roles = @object.Strategy.GetCompositeRoles(roleType.RelationType);
if (roles.Count > 0)
{
syncResponseRole.V = string.Join(
separator: Encoding.Separator,
values: roles
.Cast <IObject>()
.Select(roleObject => roleObject.Id.ToString()));
}
}
return(syncResponseRole);
}
var syncResponse = new SyncResponse
{
Objects = objects.Select(v =>
{
var @class = (Class)v.Strategy.Class;
var acl = this.acls[v];
return(new SyncResponseObject
{
I = v.Id.ToString(),
V = v.Strategy.ObjectVersion.ToString(),
T = v.Strategy.Class.IdAsString,
R = @class.WorkspaceRoleTypes
.Where(w => acl.CanRead(w) && v.Strategy.ExistRole(w.RelationType))
.Select(w => CreateSyncResponseRole(v, w))
.ToArray(),
A = this.accessControlsWriter.Write(v),
D = this.permissionsWriter.Write(v),
});
}).ToArray(),
};
syncResponse.AccessControls = this.acls.EffectivePermissionIdsByAccessControl.Keys
.Select(v => new[]
{
v.Strategy.ObjectId.ToString(),
v.Strategy.ObjectVersion.ToString(),
})
.ToArray();
return(syncResponse);
}
public void PrefetchManyInterface()
{
var i12Prefetcher = new PrefetchPolicyBuilder().WithRule(C1.Meta.I12AllorsString.RoleType).Build();
var c1Prefetcher =
new PrefetchPolicyBuilder().WithRule(C1.Meta.C1I12one2manies, i12Prefetcher)
.WithRule(C1.Meta.C1AllorsString)
.Build();
foreach (var init in this.Inits)
{
init();
this.Populate();
var connection = (DebugConnection)this.ConnectionFactory.Create(this.Database);
using (var session = this.Database.CreateSession(connection))
{
var extent = session.Extent <C1>();
session.Prefetch(c1Prefetcher, extent);
connection.Commands.Count.ShouldEqual(5);
connection.Executions.Count().ShouldEqual(6);
var stringBuilder = new StringBuilder();
foreach (C1 c1 in extent)
{
stringBuilder.Append(c1.C1AllorsString);
foreach (I12 i12 in c1.C1I12one2manies)
{
stringBuilder.Append(i12?.I12AllorsString);
}
}
connection.Commands.Count.ShouldEqual(5);
connection.Executions.Count().ShouldEqual(6);
session.Prefetch(c1Prefetcher, extent);
stringBuilder = new StringBuilder();
foreach (C1 c1 in extent)
{
stringBuilder.Append(c1.C1AllorsString);
foreach (I12 i12 in c1.C1I12one2manies)
{
stringBuilder.Append(i12?.I12AllorsString);
}
}
connection.Commands.Count.ShouldEqual(5);
connection.Executions.Count().ShouldEqual(6);
}
this.Cache.Invalidate();
connection = (DebugConnection)this.ConnectionFactory.Create(this.Database);
using (var session = this.Database.CreateSession(connection))
{
var extent = session.Extent <C1>();
session.Prefetch(c1Prefetcher, extent);
var stringBuilder = new StringBuilder();
foreach (C1 c1 in extent)
{
stringBuilder.Append(c1.C1AllorsString);
foreach (I12 i12 in c1.C1I12one2manies)
{
stringBuilder.Append(i12?.I12AllorsString);
}
}
connection.Commands.Count.ShouldEqual(5);
connection.Executions.Count().ShouldEqual(6);
}
}
}