public SessionWithMapBaseClassProperties()
{
InternalMappingManager = new MappingManager(new IMapping[] {
new AllReferencesAndIDMappingWithDatabase(),
new MapPropertiesWithBaseClassesMapping(),
new MapProperty2Mapping(),
new MapProperty1Mapping(),
new MapPropertyBaseClassMapping(),
new IMapPropertyInterfaceMapping()
},
new IDatabase[] {
new TestDatabaseMapping()
},
new QueryProviderManager(new[] { new SQLServerQueryProvider(Configuration, ObjectPool) }, Logger),
Canister.Builder.Bootstrapper.Resolve <ILogger>(),
ObjectPool);
InternalSchemaManager = new SchemaManager(InternalMappingManager, Configuration, Logger, DataModeler, Sherlock, Helper);
var TempQueryProvider = new SQLServerQueryProvider(Configuration, ObjectPool);
InternalQueryProviderManager = new QueryProviderManager(new[] { TempQueryProvider }, Logger);
CacheManager = Canister.Builder.Bootstrapper.Resolve <BigBook.Caching.Manager>();
CacheManager.Cache().Clear();
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandBaseClass"/> class.
/// </summary>
/// <param name="mappingManager">The mapping manager.</param>
/// <param name="queryProviderManager">The query provider manager.</param>
/// <param name="cache">The cache.</param>
/// <param name="objects">The objects.</param>
protected CommandBaseClass(MappingManager mappingManager, QueryProviderManager queryProviderManager, ICache cache, object[] objects)
{
QueryProviderManager = queryProviderManager;
Objects = (objects ?? Array.Empty <object>()).Where(x => x != null).ToArray();
MappingManager = mappingManager;
Cache = cache;
}
public void Creation()
{
var TempQueryProvider = new SQLServerQueryProvider(Configuration, ObjectPool);
var TestObject = new QueryProviderManager(new[] { TempQueryProvider }, Logger);
Assert.Equal(SqlClientFactory.Instance, TestObject.Providers.Keys.First());
Assert.Equal(TempQueryProvider, TestObject.Providers.Values.First());
}
public void CreateBatch()
{
var TempQueryProvider = new SQLServerQueryProvider(Configuration, ObjectPool);
var TestObject = new QueryProviderManager(new[] { TempQueryProvider }, Logger);
var Result = TestObject.CreateBatch(new MockDatabaseMapping(), DynamoFactory);
Assert.NotNull(Result);
}
/// <summary>
/// Creates the batch and gets the list of objects seen.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="dynamoFactory">The dynamo factory.</param>
/// <param name="Batch">The batch.</param>
/// <param name="ObjectsSeen">The objects seen.</param>
private void CreateBatch(IMappingSource source, DynamoFactory dynamoFactory, out SQLHelper Batch, out List <object> ObjectsSeen)
{
Batch = QueryProviderManager.CreateBatch(source.Source, dynamoFactory);
ObjectsSeen = new List <object>();
for (int x = 0, ObjectsLength = Objects.Length; x < ObjectsLength; ++x)
{
Delete(Objects[x], source, Batch, ObjectsSeen);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="QueryTranslator{TObject}"/> class.
/// </summary>
/// <param name="mappingManager">The mapping manager.</param>
/// <param name="queryProviderManager">The query provider manager.</param>
/// <exception cref="ArgumentNullException">mappingManager or queryProviderManager</exception>
public QueryTranslator(MappingManager mappingManager,
QueryProviderManager queryProviderManager)
{
MappingManager = mappingManager ?? throw new ArgumentNullException(nameof(mappingManager));
QueryProviderManager = queryProviderManager ?? throw new ArgumentNullException(nameof(queryProviderManager));
Builders = new Dictionary <IMappingSource, QueryData <TObject> >();
foreach (var Source in MappingManager.ReadSources.Where(x => x.GetChildMappings(typeof(TObject)).Any()))
{
Builders.Add(Source, new QueryData <TObject>(Source));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Session"/> class.
/// </summary>
/// <param name="mappingManager">The mapping manager.</param>
/// <param name="schemaManager">The schema manager.</param>
/// <param name="queryProviderManager">The query provider manager.</param>
/// <param name="logger">The logger.</param>
/// <param name="cacheManager">The cache manager.</param>
/// <param name="dynamoFactory">The dynamo factory.</param>
/// <exception cref="ArgumentNullException">
/// cacheManager or aopManager or mappingManager or schemaManager or queryProviderManager
/// </exception>
public Session(MappingManager mappingManager,
SchemaManager schemaManager,
QueryProviderManager queryProviderManager,
ILogger logger,
BigBook.Caching.Manager cacheManager,
DynamoFactory dynamoFactory)
{
MappingManager = mappingManager ?? throw new ArgumentNullException(nameof(mappingManager));
QueryProviderManager = queryProviderManager ?? throw new ArgumentNullException(nameof(queryProviderManager));
Commands = new List <Commands.Interfaces.ICommand>();
Logger = logger ?? throw new ArgumentNullException(nameof(logger));
Cache = cacheManager?.Cache();
DynamoFactory = dynamoFactory;
}
/// <summary>
/// Mapping source
/// </summary>
/// <param name="mappings">Mappings associated with the source</param>
/// <param name="source">Database source</param>
/// <param name="queryProvider">The query provider.</param>
/// <param name="logger">Logging object</param>
/// <param name="objectPool">The object pool.</param>
/// <exception cref="ArgumentNullException">queryProvider or source</exception>
public MappingSource(
IEnumerable <IMapping> mappings,
IDatabase source,
QueryProviderManager queryProvider,
ILogger logger,
ObjectPool <StringBuilder> objectPool)
{
Source = source ?? throw new ArgumentNullException(nameof(source));
Logger = logger ?? Log.Logger ?? new LoggerConfiguration().CreateLogger() ?? throw new ArgumentNullException(nameof(logger));
Logger.Information("Setting up {Name:l}", source.Name);
QueryProvider = queryProvider ?? throw new ArgumentNullException(nameof(queryProvider));
ConcreteTypes = Array.Empty <Type>();
mappings ??= Array.Empty <IMapping>();
IsDebug = Logger.IsEnabled(LogEventLevel.Debug);
var TempSourceOptions = Source.SourceOptions;
if (!(TempSourceOptions is null))
{
CanRead = (TempSourceOptions.Access & SourceAccess.Read) != 0;
CanWrite = (TempSourceOptions.Access & SourceAccess.Write) != 0;
ApplyAnalysis = TempSourceOptions.Analysis == SchemaAnalysis.ApplyAnalysis;
GenerateAnalysis = TempSourceOptions.Analysis == SchemaAnalysis.GenerateAnalysis;
GenerateSchema = TempSourceOptions.SchemaUpdate == SchemaGeneration.GenerateSchemaChanges;
UpdateSchema = TempSourceOptions.SchemaUpdate == SchemaGeneration.UpdateSchema;
Optimize = TempSourceOptions.Optimize;
}
Order = Source.Order;
ChildTypes = new ListMapping <Type, Type>();
ParentTypes = new ListMapping <Type, Type>();
ObjectPool = objectPool;
Logger.Information("Adding mappings for {Name:l}", Source.Name);
Mappings = mappings.ToDictionary(x => x.ObjectType);
Logger.Information("Setting up type graphs for {Name:l}", Source.Name);
TypeGraphs = Mappings.ToDictionary(Item => Item.Key, Item => Generator.Generate(Item.Key, Mappings));
SetupChildTypes();
MergeMappings();
SetupParentTypes();
ReduceMappings();
RemoveDeadMappings();
SetupAutoIDs();
}
/// <summary>
/// Deletes the joins if it needs to.
/// </summary>
/// <param name="object">The object.</param>
/// <param name="source">The source.</param>
/// <param name="batch">The batch.</param>
/// <param name="ManyToManyProperty">The many to many property.</param>
/// <param name="ManyToManyValueList">The many to many value list.</param>
private void DeleteJoins(object @object, IMappingSource source, SQLHelper batch, IManyToManyProperty ManyToManyProperty, IList ManyToManyValueList)
{
if (ManyToManyProperty.DatabaseJoinsCascade)
{
return;
}
ManyToManyValueList.Clear();
var LinksGenerator = QueryProviderManager.CreateGenerator(ManyToManyProperty.ParentMapping.ObjectType, source);
var TempQueries = LinksGenerator.GenerateQueries(QueryType.JoinsDelete, @object, ManyToManyProperty);
for (int x = 0, TempQueriesLength = TempQueries.Length; x < TempQueriesLength; ++x)
{
var TempQuery = TempQueries[x];
batch.AddQuery(TempQuery.DatabaseCommandType, TempQuery.QueryString, TempQuery.Parameters !);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MappingManager"/> class.
/// </summary>
/// <param name="mappings">The mappings.</param>
/// <param name="sources">The sources.</param>
/// <param name="queryProvider">The query provider.</param>
/// <param name="logger">The logger.</param>
/// <param name="objectPool">The object pool.</param>
/// <exception cref="ArgumentNullException">logger</exception>
public MappingManager(
IEnumerable <IMapping> mappings,
IEnumerable <IDatabase> sources,
QueryProviderManager queryProvider,
ILogger logger,
ObjectPool <StringBuilder> objectPool)
{
Logger = logger ?? Log.Logger ?? new LoggerConfiguration().CreateLogger() ?? throw new ArgumentNullException(nameof(logger));
ObjectPool = objectPool ?? throw new ArgumentNullException(nameof(objectPool));
mappings ??= Array.Empty <IMapping>();
var Debug = Logger.IsEnabled(LogEventLevel.Debug);
Logger.Information("Setting up mapping information");
var TempSourceMappings = new ListMapping <Type, IMapping>();
foreach (var Item in mappings)
{
TempSourceMappings.Add(Item.DatabaseConfigType, Item);
}
var FinalList = new ConcurrentBag <IMappingSource>();
TempSourceMappings.Keys.ForEachParallel(Key =>
{
FinalList.Add(new MappingSource(TempSourceMappings[Key],
sources.FirstOrDefault(x => x.GetType() == Key),
queryProvider,
Logger,
ObjectPool));
});
Sources = FinalList.OrderBy(x => x.Order).ToArray();
WriteSources = Sources.Where(x => x.CanWrite).ToArray();
ReadSources = Sources.Where(x => x.CanRead).ToArray();
if (Debug)
{
var Builder = ObjectPool.Get();
Builder.AppendLine("Final Mappings:");
for (var i = 0; i < Sources.Length; i++)
{
Builder.AppendLine(Sources[i].ToString());
}
Logger.Debug("{Info:l}", Builder.ToString());
ObjectPool.Return(Builder);
}
}
public SessionWithManyToManyPropertiesSelfReferencing()
{
InternalMappingManager = new MappingManager(new IMapping[] {
new ManyToManyPropertySelfReferencingMapping()
},
new IDatabase[] {
new TestDatabaseMapping()
},
new QueryProviderManager(new[] { new SQLServerQueryProvider(Configuration, ObjectPool) }, Logger),
Canister.Builder.Bootstrapper.Resolve <ILogger>(),
ObjectPool);
InternalSchemaManager = new SchemaManager(InternalMappingManager, Configuration, Logger, DataModeler, Sherlock, Helper);
var TempQueryProvider = new SQLServerQueryProvider(Configuration, ObjectPool);
InternalQueryProviderManager = new QueryProviderManager(new[] { TempQueryProvider }, Logger);
CacheManager = Canister.Builder.Bootstrapper.Resolve <BigBook.Caching.Manager>();
CacheManager.Cache().Clear();
}
public void CreateGenerator()
{
var Mappings = new MappingSource(new IMapping[] {
new BaseClass1Mapping(),
new ConcreteClass1Mapping(),
new ConcreteClass2Mapping(),
new ConcreteClass3Mapping(),
new IInterface1Mapping(),
new IInterface2Mapping()
},
new MockDatabaseMapping(),
new QueryProviderManager(new[] { new SQLServerQueryProvider(Configuration, ObjectPool) }, Logger),
Canister.Builder.Bootstrapper.Resolve <ILogger>(),
ObjectPool);
var TempQueryProvider = new SQLServerQueryProvider(Configuration, ObjectPool);
var TestObject = new QueryProviderManager(new[] { TempQueryProvider }, Logger);
var Result = TestObject.CreateGenerator <ConcreteClass1>(Mappings);
Assert.NotNull(Result);
Assert.Equal(typeof(ConcreteClass1), Result.AssociatedType);
}
/// <summary>
/// Deletes the specified object.
/// </summary>
/// <param name="object">The object.</param>
/// <param name="source">The source.</param>
/// <param name="batch">The batch.</param>
/// <param name="objectsSeen">The objects seen.</param>
private void Delete(object? @object, IMappingSource source, SQLHelper batch, IList <object> objectsSeen)
{
if (@object is null ||
WasObjectSeen(@object, objectsSeen, source) ||
!CanExecute(@object, source))
{
return;
}
objectsSeen.Add(@object);
DeleteCascade(@object, source, batch, objectsSeen);
var Generator = QueryProviderManager.CreateGenerator(@object.GetType(), source);
var Queries = Generator.GenerateQueries(QueryType.Delete, @object);
for (int x = 0, QueriesLength = Queries.Length; x < QueriesLength; x++)
{
var TempQuery = Queries[x];
batch.AddQuery(TempQuery.DatabaseCommandType, TempQuery.QueryString, TempQuery.Parameters !);
}
RemoveItemsFromCache(@object);
}
/// <summary>
/// Initializes a new instance of the <see cref="DeleteCommand"/> class.
/// </summary>
/// <param name="mappingManager">The mapping manager.</param>
/// <param name="queryProviderManager">The query provider manager.</param>
/// <param name="cache">The cache.</param>
/// <param name="objectsToDelete">The objects to delete.</param>
public DeleteCommand(MappingManager mappingManager, QueryProviderManager queryProviderManager, ICache cache, params object[] objectsToDelete)
: base(mappingManager, queryProviderManager, cache, objectsToDelete)
{
}
