public void GenerateDefaultQueriesConcreteClass2()
{
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 Result = new SQLServerGenerator <ConcreteClass2>(Mappings, ObjectPool);
Assert.Equal("DELETE FROM [dbo].[IInterface1_] WHERE [dbo].[IInterface1_].[ID_]=@ID;\r\n", Result.GenerateQueries(QueryType.Delete, new ConcreteClass2())[0].QueryString);
Assert.Equal("DECLARE @IInterface1_ID_Temp AS INT;", Result.GenerateDeclarations(QueryType.Insert)[2].QueryString);
Assert.Equal("DECLARE @BaseClass1_ID_Temp AS BIGINT;", Result.GenerateDeclarations(QueryType.Insert)[1].QueryString);
Assert.Equal("DECLARE @ConcreteClass2_ID_Temp AS BIGINT;", Result.GenerateDeclarations(QueryType.Insert)[0].QueryString);
Assert.Equal(@"INSERT INTO [dbo].[IInterface1_] DEFAULT VALUES;
SET @IInterface1_ID_Temp=SCOPE_IDENTITY();
SELECT @IInterface1_ID_Temp AS [ID];
INSERT INTO [dbo].[BaseClass1_]([dbo].[BaseClass1_].[BaseClassValue1_],[dbo].[BaseClass1_].[IInterface1_ID_]) VALUES (@BaseClassValue1,@IInterface1_ID_Temp);
SET @BaseClass1_ID_Temp=SCOPE_IDENTITY();
INSERT INTO [dbo].[ConcreteClass2_]([dbo].[ConcreteClass2_].[InterfaceValue_],[dbo].[ConcreteClass2_].[BaseClass1_ID_]) VALUES (@InterfaceValue,@BaseClass1_ID_Temp);
", Result.GenerateQueries(QueryType.Insert, new ConcreteClass2())[0].QueryString);
Assert.Equal(@"UPDATE [dbo].[BaseClass1_]
SET [dbo].[BaseClass1_].[BaseClassValue1_]=@BaseClassValue1
FROM [dbo].[BaseClass1_]
INNER JOIN [dbo].[IInterface1_] ON [dbo].[BaseClass1_].[IInterface1_ID_]=[dbo].[IInterface1_].[ID_]
WHERE [dbo].[IInterface1_].[ID_]=@ID;
UPDATE [dbo].[ConcreteClass2_]
SET [dbo].[ConcreteClass2_].[InterfaceValue_]=@InterfaceValue
FROM [dbo].[ConcreteClass2_]
INNER JOIN [dbo].[BaseClass1_] ON [dbo].[ConcreteClass2_].[BaseClass1_ID_]=[dbo].[BaseClass1_].[ID_]
INNER JOIN [dbo].[IInterface1_] ON [dbo].[BaseClass1_].[IInterface1_ID_]=[dbo].[IInterface1_].[ID_]
WHERE [dbo].[IInterface1_].[ID_]=@ID;
", Result.GenerateQueries(QueryType.Update, new ConcreteClass2())[0].QueryString);
Assert.Equal(@"SELECT [dbo].[IInterface1_].[ID_] AS [ID],[dbo].[BaseClass1_].[BaseClassValue1_] AS [BaseClassValue1],[dbo].[ConcreteClass2_].[InterfaceValue_] AS [InterfaceValue]
FROM [dbo].[ConcreteClass2_]
INNER JOIN [dbo].[BaseClass1_] ON [dbo].[ConcreteClass2_].[BaseClass1_ID_]=[dbo].[BaseClass1_].[ID_]
INNER JOIN [dbo].[IInterface1_] ON [dbo].[BaseClass1_].[IInterface1_ID_]=[dbo].[IInterface1_].[ID_]
ORDER BY [dbo].[IInterface1_].[ID_];", Result.GenerateQueries(QueryType.LinqQuery, new ConcreteClass2())[0].QueryString);
}
public void Creation()
{
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 Result = new SQLServerGenerator <ConcreteClass1>(Mappings, ObjectPool);
Assert.Equal(typeof(ConcreteClass1), Result.AssociatedType);
Assert.Equal(Mappings, Result.MappingInformation);
}
private void Initialize()
{
SQLServerGenerator generator = new SQLServerGenerator(this.Config.Defination.Connection.ConnectionString);
this.DatabaseModel = generator.CreateDatabaseModel();
this.DataModels = new List <DataModel>();
this.RelationshipModels = new List <RelationshipModel>();
Func <string, string, bool> IsSchemaMatch = (schemaName, expression) =>
{
if (expression == "*")
{
return(true);
}
else
{
return(schemaName.Equals(expression, StringComparison.OrdinalIgnoreCase));
}
};
Func <string, string, bool> IsNameMatch = (dataName, expression) =>
{
if (expression.StartsWith("^") && expression.EndsWith("$"))
{
return(Regex.IsMatch(dataName, expression));
}
else
{
return(dataName.Equals(expression, StringComparison.OrdinalIgnoreCase));
}
};
if ((this.DatabaseModel.Tables != null) && (this.Config.Defination.Storages.Tables != null))
{
foreach (DataModel item in this.DatabaseModel.Tables)
{
foreach (var storageConfig in this.Config.Defination.Storages.Tables)
{
if (IsSchemaMatch(item.Schema, storageConfig.Schema) &&
IsNameMatch(item.Name, storageConfig.Expression))
{
this.DataModels.Add(item);
break;
}
}
}
}
if ((this.DatabaseModel.Views != null) && (this.Config.Defination.Storages.Views != null))
{
foreach (DataModel item in this.DatabaseModel.Views)
{
foreach (var storageConfig in this.Config.Defination.Storages.Views)
{
if (IsSchemaMatch(item.Schema, storageConfig.Schema) &&
IsNameMatch(item.Name, storageConfig.Expression))
{
this.DataModels.Add(item);
break;
}
}
}
}
if (this.Config.Defination.Models != null)
{
foreach (var modelConfig in this.Config.Defination.Models)
{
switch (modelConfig.Action)
{
case DatabaseConfig.OperationAction.Add:
case DatabaseConfig.OperationAction.Update:
{
List <DataModel> targets = new List <DataModel>();
if (modelConfig.Action == DatabaseConfig.OperationAction.Add)
{
ViewModel target = new ViewModel();
target.Schema = modelConfig.Schema;
target.Name = modelConfig.Expression;
target.Description = modelConfig.Description;
targets.Add(target);
this.DataModels.AddRange(targets);
}
else
{
for (int i = 0; i < this.DataModels.Count; i++)
{
if (IsSchemaMatch(this.DataModels[i].Schema, modelConfig.Schema) &&
IsNameMatch(this.DataModels[i].Name, modelConfig.Expression))
{
if (modelConfig.Description != null)
{
this.DataModels[i].Description = modelConfig.Description;
}
targets.Add(this.DataModels[i]);
}
}
}
if (modelConfig.Columns != null)
{
foreach (var columnConfig in modelConfig.Columns)
{
switch (columnConfig.Action)
{
case DatabaseConfig.OperationAction.Add:
case DatabaseConfig.OperationAction.Update:
foreach (var target in targets)
{
ColumnModel column = null;
if (columnConfig.Action == DatabaseConfig.OperationAction.Add)
{
if (!target.Columns.Any(p => p.Name.Equals(columnConfig.Name, StringComparison.OrdinalIgnoreCase)))
{
column = new ColumnModel(columnConfig.Name);
target.Columns.Add(column);
}
}
else
{
column = target.Columns.FirstOrDefault(p => p.Name.Equals(columnConfig.Name, StringComparison.OrdinalIgnoreCase));
}
if (column != null)
{
if (columnConfig.Name != null)
{
column.Name = columnConfig.Name;
}
if (columnConfig.Type != null)
{
column.Type = columnConfig.Type.Value;
}
if (columnConfig.Length != null)
{
column.Length = columnConfig.Length.Value;
}
if (columnConfig.Precision != null)
{
column.Precision = columnConfig.Precision.Value;
}
if (columnConfig.Scale != null)
{
column.Scale = columnConfig.Scale.Value;
}
if (columnConfig.Nullable != null)
{
column.Nullable = columnConfig.Nullable.Value;
}
if (columnConfig.Collation != null)
{
column.Collation = columnConfig.Collation;
}
if (columnConfig.DefaultValue != null)
{
column.DefaultValue = columnConfig.DefaultValue;
}
if (columnConfig.Description != null)
{
column.Description = columnConfig.Description;
}
}
}
break;
case DatabaseConfig.OperationAction.Remove:
foreach (var target in targets)
{
for (int i = target.Columns.Count - 1; i >= 0; i--)
{
if (target.Columns[i].Name.Equals(columnConfig.Name, StringComparison.OrdinalIgnoreCase))
{
target.Columns.RemoveAt(i);
}
}
}
break;
default:
break;
}
}
}
}
break;
case DatabaseConfig.OperationAction.Remove:
for (int i = this.DataModels.Count - 1; i >= 0; i--)
{
if (IsSchemaMatch(this.DataModels[i].Schema, modelConfig.Schema) &&
IsNameMatch(this.DataModels[i].Name, modelConfig.Expression))
{
this.DataModels.RemoveAt(i);
}
}
break;
default:
break;
}
}
}
foreach (var relationshipMode in this.DatabaseModel.Relationships)
{
if (this.DataModels.Any(p => IsSchemaMatch(p.Schema, relationshipMode.PrincipalEnd.Schema) && IsNameMatch(p.Name, relationshipMode.PrincipalEnd.Table)) &&
this.DataModels.Any(p => IsSchemaMatch(p.Schema, relationshipMode.DependentEnd.Schema) && IsNameMatch(p.Name, relationshipMode.DependentEnd.Table)))
{
this.RelationshipModels.Add(relationshipMode);
}
}
}
