private static RelationalModel CreateModel()
{
var model = new RelationalModel("dbo");
var dbo = model["dbo"];
var secondary = model.AddSchema("secondary");
var people = dbo.AddTable("people");
var peopleId = people.AddColumn("id", true);
people.AddColumn("name", false);
var peopleFavoritePetId = people.AddColumn("favoritePetId", false);
var pet = secondary.AddTable("pet");
var petId = pet.AddColumn("id", true);
pet.AddColumn("name", false);
var petOwnerId = pet.AddColumn("ownerPeopleId", false);
people.AddForeignKeyTo(pet)
.AddColumnPair(peopleFavoritePetId, petId);
pet.AddForeignKeyTo(people)
.AddColumnPair(petOwnerId, peopleId);
return(model);
}
protected override void ProcessModelAnnotations(
Dictionary <string, object?> annotations, IModel model, SlimModel slimModel, bool runtime)
{
base.ProcessModelAnnotations(annotations, model, slimModel, runtime);
if (runtime)
{
annotations[RelationalAnnotationNames.RelationalModel] =
RelationalModel.Create(slimModel, RelationalDependencies.RelationalAnnotationProvider);
}
else
{
if (annotations.TryGetValue(RelationalAnnotationNames.DbFunctions, out var functions))
{
var slimFunctions = new SortedDictionary <string, IDbFunction>();
foreach (var functionPair in (SortedDictionary <string, IDbFunction>)functions !)
{
var slimFunction = Create(functionPair.Value, slimModel);
slimFunctions[functionPair.Key] = slimFunction;
foreach (var parameter in functionPair.Value.Parameters)
{
var slimParameter = Create(parameter, slimFunction);
CreateAnnotations(parameter, slimParameter, static (convention, annotations, source, target, runtime) =>
private void Combine(RelationalModel model, SqlAnnotationsCollection <Annotation> annotations)
{
foreach (var table in model.Tables)
{
var tableAnnotations = annotations.TableAnnotationResults
.Where(a => a.TableName == table.Name)
.Select(a => a.Result);
foreach (var tableAnnotation in tableAnnotations)
{
table.Annotations.Add(tableAnnotation);
}
foreach (var column in table.Columns)
{
var columnAnnotations = annotations.ColumnAnnotationResults
.Where(a => a.TableName == table.Name && a.ColumnName == column.Name)
.Select(a => a.Result);
foreach (var columnAnnotation in columnAnnotations)
{
column.Annotations.Add(columnAnnotation);
}
}
}
}
public override List <String> Execute(RelationalModel model)
{
return(model
.From <Customer>()
.Where(c => c.Name.StartsWith(Prefix)).Select(c => c.Name)
.ToList());
}
protected override void ProcessModelAnnotations(
Dictionary <string, object?> annotations, IModel model, RuntimeModel runtimeModel, bool runtime)
{
base.ProcessModelAnnotations(annotations, model, runtimeModel, runtime);
if (runtime)
{
annotations[RelationalAnnotationNames.RelationalModel] =
RelationalModel.Create(runtimeModel, RelationalDependencies.RelationalAnnotationProvider, designTime: false);
}
else
{
annotations.Remove(RelationalAnnotationNames.Collation);
if (annotations.TryGetValue(RelationalAnnotationNames.DbFunctions, out var functions))
{
var runtimeFunctions = new SortedDictionary <string, IDbFunction>(StringComparer.Ordinal);
foreach (var functionPair in (SortedDictionary <string, IDbFunction>)functions !)
{
var runtimeFunction = Create(functionPair.Value, runtimeModel);
runtimeFunctions[functionPair.Key] = runtimeFunction;
foreach (var parameter in functionPair.Value.Parameters)
{
var runtimeParameter = Create(parameter, runtimeFunction);
CreateAnnotations(parameter, runtimeParameter, static (convention, annotations, source, target, runtime) =>
public static void Execute(this RelationalModel model, Batch batch)
{
model.DoExecute(batch);
batch.Inserts.ForEach(x => x.Version++);
batch.Updates.ForEach(x => x.Version++);
}
public async Task RunAsync(FileOptions options)
{
logger.LogInformation("Executing {sqlFile} ...", Path.GetFullPath(options.InputSqlFile));
sqlCommandAdapter.ExecuteSqlCommand();
logger.LogDebug("Reading SQL schema ...");
RelationalModel model = relationalModelReader.ReadRelationalModel();
if (!model.Tables.Any())
{
logger.LogWarning("No tables were found ...");
return;
}
logger.LogDebug("Running Annotation Combiner ...");
annotationCombiner.ReadAnnotationsAndCombineWithModel(model);
logger.LogDebug("Generating CDM folder ...");
CdmManifestDefinition manifest = await cdmGenerator.GenerateCdmAsync(model);
logger.LogInformation("Saving CDM folder at {cdmOutput}...", Path.GetFullPath(options.OutputCdmFolder));
await manifest.SaveAsync();
logger.LogInformation("Success!");
}
/// <summary>
/// Insert one or more entities and increment the version if successful
/// </summary>
/// <param name="db"></param>
/// <param name="entities"></param>
public static void Insert(this RelationalModel db, params IEntity[] entities)
{
db._Insert(entities);
foreach (var entity in entities)
{
entity.Version++;
}
}
public async Task CdmManifestDefinitionNotContainsReferences()
{
var generator = CreateCdmGenerator();
var model = new RelationalModel();
CdmManifestDefinition manifest = await generator.GenerateCdmAsync(model);
Assert.Empty(manifest.Imports);
}
public static void Update(this RelationalModel model, params IEntity[] entities)
{
model.Update(entities);
foreach (var entity in entities)
{
entity.Version++;
}
}
public async Task CdmManifestDefinitionIsNotNull()
{
CdmGenerator generator = CreateCdmGenerator();
var model = new RelationalModel();
CdmManifestDefinition manifest = await generator.GenerateCdmAsync(model);
Assert.NotNull(manifest);
}
public void ReadAnnotationsAndCombineWithModel(RelationalModel model)
{
SqlAnnotationsCollection <SqlTypeValueAnnotation> typeValueAnnotations = annotationsReader.ReadTypeValueAnnotations();
SqlAnnotationsCollection <SqlTypeValueAnnotation> aliasedAnnotations = aliasMapper.Map(typeValueAnnotations);
SqlAnnotationsCollection <Annotation> annotations = typeValueMapper.Map(aliasedAnnotations);
Combine(model, annotations);
}
public async Task CdmManifestDefinitionWithEmptyTablesContainsEmptyEntitiesAndRelationships()
{
CdmGenerator generator = CreateCdmGenerator();
var model = new RelationalModel();
CdmManifestDefinition manifest = await generator.GenerateCdmAsync(model);
Assert.Empty(manifest.Entities);
Assert.Empty(manifest.Relationships);
}
public void SchemaAndName()
{
var model = new RelationalModel("dbo");
var dbo = model["dbo"];
var people = dbo.AddTable("people");
var peopleId = people.AddColumn("id", true);
Assert.AreEqual("dbo.people", people.SchemaAndName);
Assert.AreEqual("people.id", peopleId.TableQualifiedName);
}
public void TableAdditionalData()
{
var model = new RelationalModel("dbo");
var people = model.DefaultSchema.AddTable("people");
people.SetAdditionalData("a", 18);
people.SetAdditionalData("a", 21);
Assert.AreEqual(21, (int)people.GetAdditionalData("A"));
}
protected override void InitializeModel(IModel model, bool preValidation)
{
if (preValidation)
{
model.AddRuntimeAnnotation(RelationalAnnotationNames.ModelDependencies, RelationalDependencies);
}
else
{
RelationalModel.Add(model, RelationalDependencies.RelationalAnnotationProvider);
}
}
public async Task <CdmManifestDefinition> GenerateCdmAsync(RelationalModel model)
{
CdmCorpusDefinition corpus = new CdmCorpusDefinition();
CdmReferenceResolver resolver = new CdmReferenceResolver(options.ManifestName, options.EntitiesVersion);
var outputManifestFile = Path.Combine(Path.GetFullPath(options.OutputFolder), resolver.GetManifestFileName());
if (File.Exists(outputManifestFile))
{
if (options.OverrideExistingManifest)
{
File.Delete(outputManifestFile);
}
else
{
throw new Exception($"Manifest {outputManifestFile} already exists. Please use the override option.");
}
}
CdmFolderDefinition folder = corpus.GetLocalRootFolder(options.OutputFolder);
CdmManifestDefinition manifest = corpus.CreateCdmManifest(resolver.GetManifestName());
folder.Documents.Add(manifest);
foreach (var table in model.Tables)
{
string documentName = resolver.GetDocumentFileName(table.Name);
CdmDocumentDefinition entityDocument = corpus.CreateCdmDocument(documentName);
folder.Documents.Add(entityDocument);
var entityGenerator = new CdmEntityGenerator(corpus, resolver, entityDocument, options.EntitiesVersion);
CdmEntityDefinition entity = entityGenerator.GenerateEntity(table);
manifest.Entities.Add(entity);
var relationshipGenerator = new CdmEntityRelationshipGenerator(corpus, resolver);
IEnumerable <CdmE2ERelationship> relationships = relationshipGenerator.GenerateRelationships(table);
manifest.Relationships.AddRange(relationships);
}
if (options.HasTimestamps)
{
await manifest.FileStatusCheckAsync();
}
if (options.HasVirtualPartition)
{
CreateVirtualPartitionOnEntities(corpus, manifest);
}
return(manifest);
}
public void ReadsNonNullRelationalModel()
{
var sql = @"CREATE TABLE Customer (
CUSTOMER_ID INT
);";
ExecuteSqlCommand(sql);
IRelationalModelReader reader = CreateRelationalModelReader();
RelationalModel model = reader.ReadRelationalModel();
Assert.NotNull(model);
}
public async Task CdmManifestDefinitionContainsEntities()
{
var generator = CreateCdmGenerator();
var model = new RelationalModel()
{
Tables = new[] { new Table("Customer") }
};
CdmManifestDefinition manifest = await generator.GenerateCdmAsync(model);
Assert.NotNull(manifest.Entities);
Assert.Single(manifest.Entities);
}
public void ColumnAdditionalData()
{
var model = new RelationalModel();
var dbo = model.AddSchema("dbo");
var people = dbo.AddTable("people");
var peopleId = people.AddColumn("id", true);
peopleId.SetAdditionalData("a", 18);
peopleId.SetAdditionalData("a", 21);
Assert.AreEqual(21, (int)people["ID"].GetAdditionalData("A"));
}
public void ReadsTableName(string name, string expected)
{
var sql = $@"CREATE TABLE {name} (
CUSTOMER_ID INT
);";
ExecuteSqlCommand(sql);
IRelationalModelReader reader = CreateRelationalModelReader();
RelationalModel model = reader.ReadRelationalModel();
Table table = model.GetTable();
Assert.Equal(expected, table.Name);
}
public void ReadsSingleTable()
{
var sql = @"CREATE TABLE Customer (
CUSTOMER_ID INT
);";
ExecuteSqlCommand(sql);
IRelationalModelReader reader = CreateRelationalModelReader();
RelationalModel model = reader.ReadRelationalModel();
IEnumerable <Table> tables = model.Tables;
Assert.Single(tables);
}
public async Task CdmManifestDefinitionIsValid()
{
var generator = CreateCdmGenerator();
var model = new RelationalModel()
{
Tables = new[] { new Table("Customer") }
};
CdmManifestDefinition manifest = await generator.GenerateCdmAsync(model);
bool isValid = manifest.Validate();
Assert.True(isValid);
}
public void ReadsSingleColumn()
{
var sql = @"CREATE TABLE Customer (
CUSTOMER_ID INT
);";
ExecuteSqlCommand(sql);
IRelationalModelReader reader = CreateRelationalModelReader();
RelationalModel model = reader.ReadRelationalModel();
IEnumerable <Column> columns = model.GetTable().Columns;
Assert.Single(columns);
}
public void ReadsColumnLength()
{
var sql = @"CREATE TABLE Customer (
CUSTOMER_ID VARCHAR(10)
);";
ExecuteSqlCommand(sql);
IRelationalModelReader reader = CreateRelationalModelReader();
RelationalModel model = reader.ReadRelationalModel();
Column column = model.GetColumn();
Assert.NotNull(column.Length);
Assert.Equal(10, column.Length.MaxSize);
}
public async Task CdmManifestDefinitionContainsRelationships()
{
var generator = CreateCdmGenerator();
var fk = new Table("Customer").WithColumn("ID", SqlDbType.Int).GetColumn();
var table = new Table("CustomerAddresses").WithColumn("C_ID", SqlDbType.Int, foreignKey: fk);
var model = new RelationalModel()
{
Tables = new[] { table }
};
CdmManifestDefinition manifest = await generator.GenerateCdmAsync(model);
Assert.NotNull(manifest.Relationships);
Assert.Single(manifest.Relationships);
}
public void ReadsColumnTable()
{
var sql = @"CREATE TABLE Customer (
CUSTOMER_ID INT
);";
ExecuteSqlCommand(sql);
IRelationalModelReader reader = CreateRelationalModelReader();
RelationalModel model = reader.ReadRelationalModel();
Table table = model.GetTable();
Column column = model.GetColumn();
Assert.NotNull(column.Table);
Assert.Same(table, column.Table);
}
public async Task CdmManifestDefinitionNotContainsModifiedTimesWhenHasTimestampsIsFalse()
{
var options = new CdmGenerationOptions()
{
HasTimestamps = false
};
var generator = CreateCdmGenerator(options);
var model = new RelationalModel()
{
Tables = new[] { new Table("Customer") }
};
CdmManifestDefinition manifest = await generator.GenerateCdmAsync(model);
Assert.Null(manifest.LastFileStatusCheckTime);
}
public async Task CdmManifestDefinitionChildEntityContainsModifiedTimesWhenHasTimestampsIsTrue()
{
var options = new CdmGenerationOptions()
{
HasTimestamps = true
};
var generator = CreateCdmGenerator(options);
var model = new RelationalModel()
{
Tables = new[] { new Table("Customer") }
};
CdmManifestDefinition manifest = await generator.GenerateCdmAsync(model);
var child = manifest.Entities.First();
Assert.NotNull(child.LastFileStatusCheckTime);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public StoreFunction(IRuntimeDbFunction dbFunction, RelationalModel model)
: base(dbFunction.Name, dbFunction.Schema, model)
{
DbFunctions = new SortedDictionary <string, IDbFunction>(StringComparer.Ordinal)
{
{ dbFunction.ModelName, dbFunction }
};
IsBuiltIn = dbFunction.IsBuiltIn;
ReturnType = dbFunction.StoreType;
Parameters = new StoreFunctionParameter[dbFunction.Parameters.Count];
for (var i = 0; i < dbFunction.Parameters.Count; i++)
{
Parameters[i] = new StoreFunctionParameter(this, (IRuntimeDbFunctionParameter)dbFunction.Parameters[i]);
}
dbFunction.StoreFunction = this;
}
