public override Expression ApplyPolicy(Expression expression, MemberInfo member)
{
if (this.policy.operations.TryGetValue(member, out List <LambdaExpression> ops))
{
var result = expression;
foreach (var fnOp in ops)
{
var pop = ExpressionEvaluator.Eval(fnOp, this.Translator.Mapper.Mapping.CanBeEvaluatedLocally);
result = this.Translator.Mapper.ApplyMapping(Expression.Invoke(pop, result));
}
var projection = result as DbProjectionExpression;
if (projection.Type != expression.Type)
{
var fnAgg = DbAggregator.GetAggregator(expression.Type, projection.Type);
projection = new DbProjectionExpression(projection.Select, projection.Projector, fnAgg);
}
return(projection);
}
return(expression);
}
public void DbAggregator_AllNonNullPrimariesAreWritten()
{
var aggregates = new[]
{
new SinglePrimaryAggregate()
{
Primary = new MyPrimary()
{
Id = 1, Name = "one"
}
},
null,
new SinglePrimaryAggregate()
{
Primary = new MyPrimary()
{
Id = 3, Name = "three"
}
},
};
var accessor = new Mock <IDbAccessor>();
var actual = 0;
accessor.Setup(a => a.WriteEntities(It.IsAny <IEnumerable <IDbEntity> >()))
.Callback <IEnumerable <IDbEntity> >((e) => actual += e.Count());
var sut = new DbAggregator();
sut.WriteAggregates(accessor.Object, aggregates);
Assert.Equal(2, actual);
}
public static IDbAccessorSlim CreateSlimAccessor(Func <ISqlBuilder> builder, AccessorExtension extensions, Func <IDbConnection> connections)
{
var db = new Db(extensions, connections);
var aggregator = new DbAggregator();
return(new DbAccessor(new DbScripter(db, builder), new DbMapper(db), new Db(extensions, connections), aggregator));
}
public void DbAggregator_AllMixedForeignsAreSavedAfterUpdate()
{
var aggregates = new[]
{
new MixedForeignsAggregate()
{
Primary = new MyPrimary()
{
Id = 1, Name = "one"
},
Foreign = new MyForeign1(),
Foreigns = new[]
{
new MyForeign2(), new MyForeign2(),
}
},
new MixedForeignsAggregate()
{
Primary = new MyPrimary()
{
Id = 2, Name = "two"
},
Foreign = new MyForeign1(),
Foreigns = new[]
{
new MyForeign2(), new MyForeign2(),
}
},
new MixedForeignsAggregate()
{
Primary = new MyPrimary()
{
Id = 3, Name = "three"
},
Foreign = new MyForeign1(),
Foreigns = new[]
{
new MyForeign2(), new MyForeign2(),
}
},
};
var accessor = new Mock <IDbAccessor>();
var actual = 0;
accessor.Setup(a => a.WriteEntities(It.IsAny <IEnumerable <IDbEntity> >()))
.Callback <IEnumerable <IDbEntity> >((e) => actual += e.Count());
var sut = new DbAggregator();
sut.WriteAggregates(accessor.Object, aggregates);
Assert.NotNull(aggregates.SingleOrDefault(a => a.Foreign.PrimaryId == 1 && a.Foreigns.All(f => f.MyPrimaryId == 1)));
Assert.NotNull(aggregates.SingleOrDefault(a => a.Foreign.PrimaryId == 2 && a.Foreigns.All(f => f.MyPrimaryId == 2)));
Assert.NotNull(aggregates.SingleOrDefault(a => a.Foreign.PrimaryId == 3 && a.Foreigns.All(f => f.MyPrimaryId == 3)));
Assert.Equal(12, actual);
}
public void DbAggregator_AggregatesWithLessThanOnePrimaryError()
{
var accessor = new Mock <IDbAccessor>();
var aggregate = new MultiPrimaryAggregate();
var sut = new DbAggregator();
Assert.Throws <InvalidAggregateStructure>(
() => sut.WriteAggregate(accessor.Object, aggregate)
);
}
public void DbAggregator_NullAggregatesAreIgnored()
{
var accessor = new Mock <IDbAccessor>();
var actual = false;
accessor.Setup(a => a.WriteEntity(It.IsAny <IDbEntity>()))
.Callback(() => actual = true);
var sut = new DbAggregator();
sut.WriteAggregate(accessor.Object, null);
Assert.False(actual);
}
public void DbAggregator_AllMultiForeignsAreUpdateAfterPrimariesAreWritten()
{
var aggregates = new[]
{
new EnumerableForeignAggregate()
{
Primary = new MyPrimary()
{
Id = 1, Name = "one"
}, Foreigns = new[]
{
new MyForeign1(), new MyForeign1(),
}
},
new EnumerableForeignAggregate()
{
Primary = new MyPrimary()
{
Id = 2, Name = "two"
}, Foreigns = new[]
{
new MyForeign1(), new MyForeign1(),
}
},
new EnumerableForeignAggregate()
{
Primary = new MyPrimary()
{
Id = 3, Name = "three"
}, Foreigns = new[]
{
new MyForeign1(), new MyForeign1(),
}
},
};
var accessor = new Mock <IDbAccessor>();
var sut = new DbAggregator();
sut.WriteAggregates(accessor.Object, aggregates);
Assert.NotNull(aggregates.SingleOrDefault(a => a.Foreigns.All(f => f.PrimaryId == 1)));
Assert.NotNull(aggregates.SingleOrDefault(a => a.Foreigns.All(f => f.PrimaryId == 2)));
Assert.NotNull(aggregates.SingleOrDefault(a => a.Foreigns.All(f => f.PrimaryId == 3)));
}
internal static AccessorSetup GetSetup(DbAccessorType type, IDb db)
{
var aggregator = new DbAggregator();
var mapper = new DbMapper(db);
Func <ISqlBuilder> builders;
switch (type)
{
case DbAccessorType.MsSql:
{
Func <IMsSqlBuilder> msbuilders = () => new MsSqlBuilder();
var msscripter = new MsSqlScripter(db, msbuilders);
return(new AccessorSetup(msscripter, mapper, aggregator));
}
case DbAccessorType.SqLite:
{
builders = () => new SqLiteBuilder();
}
break;
case DbAccessorType.MySql:
{
builders = () => new MySqlBuilder();
}
break;
case DbAccessorType.Oracle:
{
builders = () => new OracleBuilder();
}
break;
default:
throw new InvalidOperationException(string.Format("Unsupported DbAccessorType value of '{0}'", type));
}
var scripter = new DbScripter(db, builders);
return(new AccessorSetup(scripter, mapper, aggregator));
}
public void DbAggregator_AllSingleForeignsAreSavedAfterUpdate()
{
var aggregates = new[]
{
new SingleForeignAggregate()
{
Primary = new MyPrimary()
{
Id = 1, Name = "one"
}, Foreign1 = new MyForeign1()
},
new SingleForeignAggregate()
{
Primary = new MyPrimary()
{
Id = 2, Name = "two"
}, Foreign1 = new MyForeign1()
},
new SingleForeignAggregate()
{
Primary = new MyPrimary()
{
Id = 3, Name = "three"
}, Foreign1 = new MyForeign1()
},
};
var accessor = new Mock <IDbAccessor>();
var actual = 0;
accessor.Setup(a => a.WriteEntities(It.IsAny <IEnumerable <IDbEntity> >()))
.Callback <IEnumerable <IDbEntity> >((e) => actual += e.Count());
var sut = new DbAggregator();
sut.WriteAggregates(accessor.Object, aggregates);
Assert.Equal(6, actual);
}
public static void Aggregate()
{
DbAggregator.AggregateDataBase();
ServiceAggregator.AggregateService();
}
