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; }