diff --git a/backend/FwLite/FwLiteShared/FwLiteSharedKernel.cs b/backend/FwLite/FwLiteShared/FwLiteSharedKernel.cs index 075ff6b0e0..6e4a2d0e62 100644 --- a/backend/FwLite/FwLiteShared/FwLiteSharedKernel.cs +++ b/backend/FwLite/FwLiteShared/FwLiteSharedKernel.cs @@ -1,6 +1,8 @@ using System.Net; +using System.Text.Json.Serialization.Metadata; using FwLiteShared.Auth; using FwLiteShared.Events; +using FwLiteShared.Json; using FwLiteShared.Projects; using FwLiteShared.Services; using FwLiteShared.Sync; @@ -9,6 +11,7 @@ using Microsoft.Extensions.Hosting; using Microsoft.Extensions.Options; using Microsoft.JSInterop; +using MiniLcm; using Polly; using Polly.Simmy; using SIL.Harmony; @@ -115,4 +118,11 @@ private static void DecorateConstructor(this IServiceCollection servic }, descriptor.Lifetime); } } + + public static IJsonTypeInfoResolver MakeLcmCrdtExternalJsonTypeResolver(this CrdtConfig config) + { + var resolver = JsonTypeInfoResolver.Combine(config.JsonSerializerOptions.TypeInfoResolver, SharedSourceGenerationContext.Default); + resolver = resolver.AddExternalMiniLcmModifiers(); + return resolver; + } } diff --git a/backend/FwLite/FwLiteShared/Json/SharedSourceGenerationContext.cs b/backend/FwLite/FwLiteShared/Json/SharedSourceGenerationContext.cs new file mode 100644 index 0000000000..8144f23714 --- /dev/null +++ b/backend/FwLite/FwLiteShared/Json/SharedSourceGenerationContext.cs @@ -0,0 +1,31 @@ +using System.Text.Json.Serialization; +using FwLiteShared.Auth; +using FwLiteShared.Events; +using FwLiteShared.Projects; +using FwLiteShared.Services; +using LcmCrdt; +using MiniLcm.Models; +using SIL.Harmony.Db; + +namespace FwLiteShared.Json; + +[JsonSourceGenerationOptions] +[JsonSerializable(typeof(IAsyncEnumerable))] +[JsonSerializable(typeof(IAsyncEnumerable))] +[JsonSerializable(typeof(IAsyncEnumerable))] +[JsonSerializable(typeof(IProjectIdentifier))] +[JsonSerializable(typeof(ServerStatus[]))] +[JsonSerializable(typeof(LexboxServer))] +[JsonSerializable(typeof(CrdtProject))] +[JsonSerializable(typeof(ProjectData))] +[JsonSerializable(typeof(FwLiteConfig))] +[JsonSerializable(typeof(ObjectSnapshot))] +[JsonSerializable(typeof(ProjectScope))] +[JsonSerializable(typeof(IFwEvent))] +[JsonSerializable(typeof(Dictionary))] +[JsonSerializable(typeof(IReadOnlyCollection))] +public partial class SharedSourceGenerationContext : JsonSerializerContext +{ + +} + diff --git a/backend/FwLite/FwLiteShared/Services/FwLiteJson.cs b/backend/FwLite/FwLiteShared/Services/FwLiteJson.cs index 6eda2856a8..a8a578bc0a 100644 --- a/backend/FwLite/FwLiteShared/Services/FwLiteJson.cs +++ b/backend/FwLite/FwLiteShared/Services/FwLiteJson.cs @@ -20,8 +20,6 @@ public static void ConfigureJsonSerializerOptions(this IJSRuntime jsRuntime, Crd throw new InvalidOperationException("Unable to find JsonSerializerOptions property"); var options = (JsonSerializerOptions?)_jsRuntimeJsonOptionsProperty.GetValue(jsRuntime, null); if (options is null) throw new InvalidOperationException("JSRuntime.JsonSerializerOptions returned null"); - options.TypeInfoResolver = (options.TypeInfoResolver ?? new DefaultJsonTypeInfoResolver()) - .WithAddedModifier(crdtConfig.MakeJsonTypeModifier()) - .AddExternalMiniLcmModifiers(); + options.TypeInfoResolver = JsonTypeInfoResolver.Combine(options.TypeInfoResolver, crdtConfig.MakeLcmCrdtExternalJsonTypeResolver()); } } diff --git a/backend/FwLite/FwLiteWeb/FwLiteWebKernel.cs b/backend/FwLite/FwLiteWeb/FwLiteWebKernel.cs index ef73bfa266..d0fc524446 100644 --- a/backend/FwLite/FwLiteWeb/FwLiteWebKernel.cs +++ b/backend/FwLite/FwLiteWeb/FwLiteWebKernel.cs @@ -1,4 +1,7 @@ -using FwDataMiniLcmBridge; +using System.Reflection; +using System.Text.Json; +using System.Text.Json.Serialization.Metadata; +using FwDataMiniLcmBridge; using FwLiteProjectSync; using SIL.Harmony; using FwLiteShared; @@ -6,6 +9,7 @@ using FwLiteWeb.Routes; using LcmCrdt; using FwLiteWeb.Services; +using FwLiteWeb.Utils; using Microsoft.AspNetCore.Http.Json; using Microsoft.AspNetCore.SignalR; using Microsoft.Extensions.Options; @@ -32,14 +36,37 @@ public static IServiceCollection AddFwLiteWebServices(this IServiceCollection se services.AddOptions().PostConfigure>((jsonOptions, crdtConfig) => { - jsonOptions.SerializerOptions.TypeInfoResolver = crdtConfig.Value.MakeLcmCrdtExternalJsonTypeResolver(); + jsonOptions.SerializerOptions.TypeInfoResolver = jsonOptions.SerializerOptions.TypeInfoResolver.WithWebTypeInfo(crdtConfig.Value); }); services.AddOptions().PostConfigure>( (jsonOptions, crdtConfig) => { - jsonOptions.PayloadSerializerOptions.TypeInfoResolver = crdtConfig.Value.MakeLcmCrdtExternalJsonTypeResolver(); + jsonOptions.PayloadSerializerOptions.TypeInfoResolver = jsonOptions.PayloadSerializerOptions.TypeInfoResolver.WithWebTypeInfo(crdtConfig.Value); }); + services.PostConfigure(config => + { + var type = typeof(RazorComponentsServiceCollectionExtensions).Assembly.GetType( + "Microsoft.AspNetCore.Components.ServerComponentSerializationSettings"); + if (type is null) + throw new InvalidOperationException( + "Microsoft.AspNetCore.Components.ServerComponentSerializationSettings not found"); + var property = type.GetField("JsonSerializationOptions", BindingFlags.Static | BindingFlags.Public); + if (property is null) + throw new InvalidOperationException( + "ServerComponentSerializationSettings.JsonSerializationOptions property not found"); + var jsonSerializerOptions = (JsonSerializerOptions?)property.GetValue(null); + if (jsonSerializerOptions is null) + throw new InvalidOperationException( + "ServerComponentSerializationSettings.JsonSerializationOptions is null"); + jsonSerializerOptions.TypeInfoResolver = jsonSerializerOptions.TypeInfoResolver.WithWebTypeInfo(config); + + }); return services; } + + private static IJsonTypeInfoResolver WithWebTypeInfo(this IJsonTypeInfoResolver? resolver, CrdtConfig config) + { + return JsonTypeInfoResolver.Combine(resolver, config.MakeLcmCrdtExternalJsonTypeResolver()); + } } diff --git a/backend/FwLite/FwLiteWeb/Routes/AuthRoutes.cs b/backend/FwLite/FwLiteWeb/Routes/AuthRoutes.cs index 55bc0711c4..43dec3da52 100644 --- a/backend/FwLite/FwLiteWeb/Routes/AuthRoutes.cs +++ b/backend/FwLite/FwLiteWeb/Routes/AuthRoutes.cs @@ -10,6 +10,9 @@ public static class AuthRoutes { public const string CallbackRoute = "AuthRoutes_Callback"; public record ServerStatus(string DisplayName, bool LoggedIn, string? LoggedInAs, string? Authority); + + public record AuthRecord(string? Name); + public static IEndpointConventionBuilder MapAuthRoutes(this WebApplication app) { var group = app.MapGroup("/api/auth").WithOpenApi(); @@ -40,7 +43,7 @@ public static IEndpointConventionBuilder MapAuthRoutes(this WebApplication app) group.MapGet("/me/{authority}", async (AuthService authService, string authority, IOptions options) => { - return new { name = await authService.GetLoggedInName(options.Value.GetServerByAuthority(authority)) }; + return new AuthRecord(await authService.GetLoggedInName(options.Value.GetServerByAuthority(authority))); }); group.MapGet("/logout/{authority}", async (AuthService authService, string authority, IOptions options) => diff --git a/backend/FwLite/LcmCrdt.Tests/Changes/ChangeSerializationTests.cs b/backend/FwLite/LcmCrdt.Tests/Changes/ChangeSerializationTests.cs index d7f87e89fb..8cbaf1040d 100644 --- a/backend/FwLite/LcmCrdt.Tests/Changes/ChangeSerializationTests.cs +++ b/backend/FwLite/LcmCrdt.Tests/Changes/ChangeSerializationTests.cs @@ -16,8 +16,7 @@ public class ChangeSerializationTests { private static readonly Lazy LazyOptions = new(() => { - var config = new CrdtConfig(); - LcmCrdtKernel.ConfigureCrdt(config); + var config = LcmCrdtKernel.MakeConfig(); config.JsonSerializerOptions.ReadCommentHandling = JsonCommentHandling.Skip; return config.JsonSerializerOptions; }); diff --git a/backend/FwLite/LcmCrdt.Tests/Data/SnapshotDeserializationTests.cs b/backend/FwLite/LcmCrdt.Tests/Data/SnapshotDeserializationTests.cs index 9d4e331288..11d56c2bc1 100644 --- a/backend/FwLite/LcmCrdt.Tests/Data/SnapshotDeserializationTests.cs +++ b/backend/FwLite/LcmCrdt.Tests/Data/SnapshotDeserializationTests.cs @@ -9,8 +9,7 @@ public class SnapshotDeserializationTests private static readonly Lazy LazyOptions = new(() => { - var config = new CrdtConfig(); - LcmCrdtKernel.ConfigureCrdt(config); + var config = LcmCrdtKernel.MakeConfig(); config.JsonSerializerOptions.ReadCommentHandling = JsonCommentHandling.Skip; return config.JsonSerializerOptions; }); diff --git a/backend/FwLite/LcmCrdt.Tests/DataModelSnapshotTests.VerifyDbModel.verified.txt b/backend/FwLite/LcmCrdt.Tests/DataModelSnapshotTests.VerifyDbModel.verified.txt index eeff4ac2af..ad2e22b857 100644 --- a/backend/FwLite/LcmCrdt.Tests/DataModelSnapshotTests.VerifyDbModel.verified.txt +++ b/backend/FwLite/LcmCrdt.Tests/DataModelSnapshotTests.VerifyDbModel.verified.txt @@ -44,11 +44,7 @@ ComponentSenseId SnapshotId Unique ComplexFormEntryId, ComponentEntryId Unique - Annotations: - Relational:Filter: ComponentSenseId IS NULL ComplexFormEntryId, ComponentEntryId, ComponentSenseId Unique - Annotations: - Relational:Filter: ComponentSenseId IS NOT NULL Annotations: DiscriminatorProperty: Relational:FunctionName: @@ -270,7 +266,7 @@ Order (double) Required SnapshotId (no field, Guid?) Shadow FK Index Type (WritingSystemType) Required Index - WsId (WritingSystemId) Required Index + WsId (WritingSystemId) Required Index Sentinel:default Keys: Id PK Foreign keys: @@ -308,6 +304,13 @@ DateTime (DateTimeOffset) Required Annotations: Relational:ColumnName: DateTime + Annotations: + Relational:FunctionName: + Relational:Schema: + Relational:SqlQuery: + Relational:TableName: Commits + Relational:ViewName: + Relational:ViewSchema: Keys: Id PK Annotations: diff --git a/backend/FwLite/LcmCrdt/Changes/CreateEntryChange.cs b/backend/FwLite/LcmCrdt/Changes/CreateEntryChange.cs index be14afdf96..67272a7519 100644 --- a/backend/FwLite/LcmCrdt/Changes/CreateEntryChange.cs +++ b/backend/FwLite/LcmCrdt/Changes/CreateEntryChange.cs @@ -19,7 +19,7 @@ public CreateEntryChange(Entry entry) : base(entry.Id == Guid.Empty ? Guid.NewGu } [JsonConstructor] - private CreateEntryChange(Guid entityId) : base(entityId) + internal CreateEntryChange(Guid entityId) : base(entityId) { } diff --git a/backend/FwLite/LcmCrdt/Changes/CreateExampleSentenceChange.cs b/backend/FwLite/LcmCrdt/Changes/CreateExampleSentenceChange.cs index 7a246dd37c..6bf97fb3c9 100644 --- a/backend/FwLite/LcmCrdt/Changes/CreateExampleSentenceChange.cs +++ b/backend/FwLite/LcmCrdt/Changes/CreateExampleSentenceChange.cs @@ -20,7 +20,7 @@ public CreateExampleSentenceChange(ExampleSentence exampleSentence, Guid senseId } [JsonConstructor] - private CreateExampleSentenceChange(Guid entityId, Guid senseId) : base(entityId) + internal CreateExampleSentenceChange(Guid entityId, Guid senseId) : base(entityId) { SenseId = senseId; } diff --git a/backend/FwLite/LcmCrdt/Changes/CreateSenseChange.cs b/backend/FwLite/LcmCrdt/Changes/CreateSenseChange.cs index f20efbfb73..49feddc7db 100644 --- a/backend/FwLite/LcmCrdt/Changes/CreateSenseChange.cs +++ b/backend/FwLite/LcmCrdt/Changes/CreateSenseChange.cs @@ -21,7 +21,7 @@ public CreateSenseChange(Sense sense, Guid entryId) : base(sense.Id == Guid.Empt } [JsonConstructor] - private CreateSenseChange(Guid entityId, Guid entryId) : base(entityId) + internal CreateSenseChange(Guid entityId, Guid entryId) : base(entityId) { EntryId = entryId; } diff --git a/backend/FwLite/LcmCrdt/Changes/CreateWritingSystemChange.cs b/backend/FwLite/LcmCrdt/Changes/CreateWritingSystemChange.cs index 441d043df2..945c833200 100644 --- a/backend/FwLite/LcmCrdt/Changes/CreateWritingSystemChange.cs +++ b/backend/FwLite/LcmCrdt/Changes/CreateWritingSystemChange.cs @@ -31,7 +31,7 @@ public CreateWritingSystemChange(WritingSystem writingSystem, WritingSystemType } [JsonConstructor] - private CreateWritingSystemChange(Guid entityId) : base(entityId) + internal CreateWritingSystemChange(Guid entityId) : base(entityId) { } diff --git a/backend/FwLite/LcmCrdt/Changes/Entries/SetComplexFormComponentChange.cs b/backend/FwLite/LcmCrdt/Changes/Entries/SetComplexFormComponentChange.cs index b789b8f307..3bc7b46b58 100644 --- a/backend/FwLite/LcmCrdt/Changes/Entries/SetComplexFormComponentChange.cs +++ b/backend/FwLite/LcmCrdt/Changes/Entries/SetComplexFormComponentChange.cs @@ -9,7 +9,7 @@ namespace LcmCrdt.Changes.Entries; public class SetComplexFormComponentChange : EditChange, ISelfNamedType { [JsonConstructor] - protected SetComplexFormComponentChange(Guid entityId, Guid? complexFormEntryId, Guid? componentEntryId, Guid? componentSenseId) : base(entityId) + internal SetComplexFormComponentChange(Guid entityId, Guid? complexFormEntryId, Guid? componentEntryId, Guid? componentSenseId) : base(entityId) { ComplexFormEntryId = complexFormEntryId; ComponentEntryId = componentEntryId; diff --git a/backend/FwLite/LcmCrdt/CompiledModels/ChangeEntityEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/ChangeEntityEntityType.cs new file mode 100644 index 0000000000..4900b564aa --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/ChangeEntityEntityType.cs @@ -0,0 +1,140 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using SIL.Harmony.Changes; +using SIL.Harmony.Core; +using SIL.Harmony.Db.EntityConfig; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class ChangeEntityEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "SIL.Harmony.Core.ChangeEntity", + typeof(ChangeEntity), + baseEntityType); + + var commitId = runtimeEntityType.AddProperty( + "CommitId", + typeof(Guid), + propertyInfo: typeof(ChangeEntity).GetProperty("CommitId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ChangeEntity).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + commitId.TypeMapping = SqliteGuidTypeMapping.Default; + + var index = runtimeEntityType.AddProperty( + "Index", + typeof(int), + propertyInfo: typeof(ChangeEntity).GetProperty("Index", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ChangeEntity).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: 0); + index.TypeMapping = IntTypeMapping.Default.Clone( + comparer: new ValueComparer( + (int v1, int v2) => v1 == v2, + (int v) => v, + (int v) => v), + keyComparer: new ValueComparer( + (int v1, int v2) => v1 == v2, + (int v) => v, + (int v) => v), + providerValueComparer: new ValueComparer( + (int v1, int v2) => v1 == v2, + (int v) => v, + (int v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "INTEGER")); + + var change = runtimeEntityType.AddProperty( + "Change", + typeof(IChange), + propertyInfo: typeof(ChangeEntity).GetProperty("Change", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ChangeEntity).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + change.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (IChange v1, IChange v2) => object.Equals(v1, v2), + (IChange v) => v.GetHashCode(), + (IChange v) => v), + keyComparer: new ValueComparer( + (IChange v1, IChange v2) => object.Equals(v1, v2), + (IChange v) => v.GetHashCode(), + (IChange v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (IChange change) => ChangeEntityConfig.SerializeChange(change, null), + (string json) => ChangeEntityConfig.DeserializeChange(json, null)), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (IChange change) => ChangeEntityConfig.SerializeChange(change, null), + (string json) => ChangeEntityConfig.DeserializeChange(json, null)))); + change.AddAnnotation("Relational:ColumnType", "jsonb"); + + var entityId = runtimeEntityType.AddProperty( + "EntityId", + typeof(Guid), + propertyInfo: typeof(ChangeEntity).GetProperty("EntityId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ChangeEntity).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + entityId.TypeMapping = SqliteGuidTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { commitId, index }); + runtimeEntityType.SetPrimaryKey(key); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("CommitId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + required: true); + + var changeEntities = principalEntityType.AddNavigation("ChangeEntities", + runtimeForeignKey, + onDependent: false, + typeof(List>), + propertyInfo: typeof(CommitBase).GetProperty("ChangeEntities", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CommitBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "ChangeEntities"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/CommitEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/CommitEntityType.cs new file mode 100644 index 0000000000..00dd2dc529 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/CommitEntityType.cs @@ -0,0 +1,187 @@ +// +using System; +using System.Reflection; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Json.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using SIL.Harmony; +using SIL.Harmony.Core; +using SIL.Harmony.Db.EntityConfig; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class CommitEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "SIL.Harmony.Commit", + typeof(Commit), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(CommitBase).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CommitBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var clientId = runtimeEntityType.AddProperty( + "ClientId", + typeof(Guid), + propertyInfo: typeof(CommitBase).GetProperty("ClientId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CommitBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + clientId.TypeMapping = SqliteGuidTypeMapping.Default; + + var hash = runtimeEntityType.AddProperty( + "Hash", + typeof(string), + propertyInfo: typeof(Commit).GetProperty("Hash", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Commit).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + hash.TypeMapping = SqliteStringTypeMapping.Default; + + var metadata = runtimeEntityType.AddProperty( + "Metadata", + typeof(CommitMetadata), + propertyInfo: typeof(CommitBase).GetProperty("Metadata", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CommitBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + metadata.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (CommitMetadata v1, CommitMetadata v2) => object.Equals(v1, v2), + (CommitMetadata v) => v.GetHashCode(), + (CommitMetadata v) => v), + keyComparer: new ValueComparer( + (CommitMetadata v1, CommitMetadata v2) => object.Equals(v1, v2), + (CommitMetadata v) => v.GetHashCode(), + (CommitMetadata v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (CommitMetadata m) => CommitEntityConfig.Serialize(m, null), + (string json) => CommitEntityConfig.Deserialize(json, null) ?? new CommitMetadata()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (CommitMetadata m) => CommitEntityConfig.Serialize(m, null), + (string json) => CommitEntityConfig.Deserialize(json, null) ?? new CommitMetadata()))); + metadata.AddAnnotation("Relational:ColumnType", "jsonb"); + + var parentHash = runtimeEntityType.AddProperty( + "ParentHash", + typeof(string), + propertyInfo: typeof(Commit).GetProperty("ParentHash", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Commit).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + parentHash.TypeMapping = SqliteStringTypeMapping.Default; + + HybridDateTimeComplexProperty.Create(runtimeEntityType); + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + return runtimeEntityType; + } + + private static class HybridDateTimeComplexProperty + { + public static RuntimeComplexProperty Create(RuntimeEntityType declaringType) + { + var complexProperty = declaringType.AddComplexProperty("HybridDateTime", + typeof(HybridDateTime), + "SIL.Harmony.Commit.HybridDateTime#HybridDateTime", + typeof(HybridDateTime), + propertyInfo: typeof(CommitBase).GetProperty("HybridDateTime", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CommitBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + var complexType = complexProperty.ComplexType; + var counter = complexType.AddProperty( + "Counter", + typeof(long), + propertyInfo: typeof(HybridDateTime).GetProperty("Counter", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(HybridDateTime).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0L); + counter.TypeMapping = LongTypeMapping.Default.Clone( + comparer: new ValueComparer( + (long v1, long v2) => v1 == v2, + (long v) => v.GetHashCode(), + (long v) => v), + keyComparer: new ValueComparer( + (long v1, long v2) => v1 == v2, + (long v) => v.GetHashCode(), + (long v) => v), + providerValueComparer: new ValueComparer( + (long v1, long v2) => v1 == v2, + (long v) => v.GetHashCode(), + (long v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "INTEGER")); + counter.AddAnnotation("Relational:ColumnName", "Counter"); + + var dateTime = complexType.AddProperty( + "DateTime", + typeof(DateTimeOffset), + propertyInfo: typeof(HybridDateTime).GetProperty("DateTime", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(HybridDateTime).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + dateTime.TypeMapping = SqliteDateTimeTypeMapping.Default.Clone( + comparer: new ValueComparer( + (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), + (DateTimeOffset v) => v.GetHashCode(), + (DateTimeOffset v) => v), + keyComparer: new ValueComparer( + (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), + (DateTimeOffset v) => v.GetHashCode(), + (DateTimeOffset v) => v), + providerValueComparer: new ValueComparer( + (DateTime v1, DateTime v2) => v1.Equals(v2), + (DateTime v) => v.GetHashCode(), + (DateTime v) => v), + converter: new ValueConverter( + (DateTimeOffset d) => d.UtcDateTime, + (DateTime d) => new DateTimeOffset(d.Ticks, TimeSpan.Zero)), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + SqliteJsonDateTimeReaderWriter.Instance, + new ValueConverter( + (DateTimeOffset d) => d.UtcDateTime, + (DateTime d) => new DateTimeOffset(d.Ticks, TimeSpan.Zero)))); + dateTime.SetSentinelFromProviderValue(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc)); + dateTime.AddAnnotation("Relational:ColumnName", "DateTime"); + + complexType.AddAnnotation("Relational:FunctionName", null); + complexType.AddAnnotation("Relational:Schema", null); + complexType.AddAnnotation("Relational:SqlQuery", null); + complexType.AddAnnotation("Relational:TableName", "Commits"); + complexType.AddAnnotation("Relational:ViewName", null); + complexType.AddAnnotation("Relational:ViewSchema", null); + return complexProperty; + } + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "Commits"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/ComplexFormComponentEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/ComplexFormComponentEntityType.cs new file mode 100644 index 0000000000..99da1b4192 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/ComplexFormComponentEntityType.cs @@ -0,0 +1,209 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using MiniLcm.Models; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class ComplexFormComponentEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "MiniLcm.Models.ComplexFormComponent", + typeof(ComplexFormComponent), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(ComplexFormComponent).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormComponent).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var complexFormEntryId = runtimeEntityType.AddProperty( + "ComplexFormEntryId", + typeof(Guid), + propertyInfo: typeof(ComplexFormComponent).GetProperty("ComplexFormEntryId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormComponent).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + complexFormEntryId.TypeMapping = SqliteGuidTypeMapping.Default; + + var complexFormHeadword = runtimeEntityType.AddProperty( + "ComplexFormHeadword", + typeof(string), + propertyInfo: typeof(ComplexFormComponent).GetProperty("ComplexFormHeadword", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormComponent).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + complexFormHeadword.TypeMapping = SqliteStringTypeMapping.Default; + + var componentEntryId = runtimeEntityType.AddProperty( + "ComponentEntryId", + typeof(Guid), + propertyInfo: typeof(ComplexFormComponent).GetProperty("ComponentEntryId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormComponent).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + componentEntryId.TypeMapping = SqliteGuidTypeMapping.Default; + + var componentHeadword = runtimeEntityType.AddProperty( + "ComponentHeadword", + typeof(string), + propertyInfo: typeof(ComplexFormComponent).GetProperty("ComponentHeadword", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormComponent).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + componentHeadword.TypeMapping = SqliteStringTypeMapping.Default; + + var componentSenseId = runtimeEntityType.AddProperty( + "ComponentSenseId", + typeof(Guid?), + propertyInfo: typeof(ComplexFormComponent).GetProperty("ComponentSenseId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormComponent).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + componentSenseId.TypeMapping = SqliteGuidTypeMapping.Default; + componentSenseId.AddAnnotation("Relational:ColumnName", "ComponentSenseId"); + + var deletedAt = runtimeEntityType.AddProperty( + "DeletedAt", + typeof(DateTimeOffset?), + propertyInfo: typeof(ComplexFormComponent).GetProperty("DeletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormComponent).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + deletedAt.TypeMapping = SqliteDateTimeOffsetTypeMapping.Default; + + var order = runtimeEntityType.AddProperty( + "Order", + typeof(double), + propertyInfo: typeof(ComplexFormComponent).GetProperty("Order", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormComponent).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0.0); + order.TypeMapping = DoubleTypeMapping.Default.Clone( + comparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + keyComparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + providerValueComparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "REAL")); + + var snapshotId = runtimeEntityType.AddProperty( + "SnapshotId", + typeof(Guid?), + nullable: true); + snapshotId.TypeMapping = SqliteGuidTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { componentEntryId }); + + var index0 = runtimeEntityType.AddIndex( + new[] { componentSenseId }); + + var index1 = runtimeEntityType.AddIndex( + new[] { snapshotId }, + unique: true); + + var index2 = runtimeEntityType.AddIndex( + new[] { complexFormEntryId, componentEntryId }, + unique: true); + + var index3 = runtimeEntityType.AddIndex( + new[] { complexFormEntryId, componentEntryId, componentSenseId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("ComplexFormEntryId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + required: true); + + var components = principalEntityType.AddNavigation("Components", + runtimeForeignKey, + onDependent: false, + typeof(List), + propertyInfo: typeof(Entry).GetProperty("Components", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("ComponentEntryId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + required: true); + + var complexForms = principalEntityType.AddNavigation("ComplexForms", + runtimeForeignKey, + onDependent: false, + typeof(List), + propertyInfo: typeof(Entry).GetProperty("ComplexForms", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey3(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("ComponentSenseId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade); + + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey4(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SnapshotId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.SetNull, + unique: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "ComplexFormComponents"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/ComplexFormTypeEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/ComplexFormTypeEntityType.cs new file mode 100644 index 0000000000..9c501d9cc6 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/ComplexFormTypeEntityType.cs @@ -0,0 +1,118 @@ +// +using System; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using MiniLcm.Models; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class ComplexFormTypeEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "MiniLcm.Models.ComplexFormType", + typeof(ComplexFormType), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(ComplexFormType).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var deletedAt = runtimeEntityType.AddProperty( + "DeletedAt", + typeof(DateTimeOffset?), + propertyInfo: typeof(ComplexFormType).GetProperty("DeletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + deletedAt.TypeMapping = SqliteDateTimeOffsetTypeMapping.Default; + + var name = runtimeEntityType.AddProperty( + "Name", + typeof(MultiString), + propertyInfo: typeof(ComplexFormType).GetProperty("Name", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ComplexFormType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.MultiStringDbConverter()); + name.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + keyComparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()))); + name.AddAnnotation("Relational:ColumnType", "jsonb"); + + var snapshotId = runtimeEntityType.AddProperty( + "SnapshotId", + typeof(Guid?), + nullable: true); + snapshotId.TypeMapping = SqliteGuidTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { snapshotId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SnapshotId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.SetNull, + unique: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "ComplexFormType"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/EntryEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/EntryEntityType.cs new file mode 100644 index 0000000000..3144d40a37 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/EntryEntityType.cs @@ -0,0 +1,272 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using MiniLcm.Models; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class EntryEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "MiniLcm.Models.Entry", + typeof(Entry), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(Entry).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var citationForm = runtimeEntityType.AddProperty( + "CitationForm", + typeof(MultiString), + propertyInfo: typeof(Entry).GetProperty("CitationForm", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.MultiStringDbConverter()); + citationForm.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + keyComparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()))); + citationForm.AddAnnotation("Relational:ColumnType", "jsonb"); + + var complexFormTypes = runtimeEntityType.AddProperty( + "ComplexFormTypes", + typeof(IList), + propertyInfo: typeof(Entry).GetProperty("ComplexFormTypes", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + complexFormTypes.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer>( + (IList v1, IList v2) => object.Equals(v1, v2), + (IList v) => v.GetHashCode(), + (IList v) => v), + keyComparer: new ValueComparer>( + (IList v1, IList v2) => object.Equals(v1, v2), + (IList v) => v.GetHashCode(), + (IList v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter, string>( + (IList list) => LcmCrdtDbContext.Serialize(list), + (string json) => LcmCrdtDbContext.Deserialize>(json) ?? new List()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter, string>( + JsonStringReaderWriter.Instance, + new ValueConverter, string>( + (IList list) => LcmCrdtDbContext.Serialize(list), + (string json) => LcmCrdtDbContext.Deserialize>(json) ?? new List()))); + complexFormTypes.AddAnnotation("Relational:ColumnType", "jsonb"); + + var deletedAt = runtimeEntityType.AddProperty( + "DeletedAt", + typeof(DateTimeOffset?), + propertyInfo: typeof(Entry).GetProperty("DeletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + deletedAt.TypeMapping = SqliteDateTimeOffsetTypeMapping.Default; + + var lexemeForm = runtimeEntityType.AddProperty( + "LexemeForm", + typeof(MultiString), + propertyInfo: typeof(Entry).GetProperty("LexemeForm", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.MultiStringDbConverter()); + lexemeForm.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + keyComparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()))); + lexemeForm.AddAnnotation("Relational:ColumnType", "jsonb"); + + var literalMeaning = runtimeEntityType.AddProperty( + "LiteralMeaning", + typeof(RichMultiString), + propertyInfo: typeof(Entry).GetProperty("LiteralMeaning", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.RichMultiStringDbConverter()); + literalMeaning.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + keyComparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()))); + literalMeaning.AddAnnotation("Relational:ColumnType", "jsonb"); + + var note = runtimeEntityType.AddProperty( + "Note", + typeof(RichMultiString), + propertyInfo: typeof(Entry).GetProperty("Note", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.RichMultiStringDbConverter()); + note.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + keyComparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()))); + note.AddAnnotation("Relational:ColumnType", "jsonb"); + + var publishIn = runtimeEntityType.AddProperty( + "PublishIn", + typeof(List), + propertyInfo: typeof(Entry).GetProperty("PublishIn", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + publishIn.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer>( + (List v1, List v2) => object.Equals(v1, v2), + (List v) => v.GetHashCode(), + (List v) => v), + keyComparer: new ValueComparer>( + (List v1, List v2) => object.Equals(v1, v2), + (List v) => v.GetHashCode(), + (List v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter, string>( + (List list) => LcmCrdtDbContext.Serialize(list), + (string json) => string.IsNullOrWhiteSpace(json) ? new List() : LcmCrdtDbContext.Deserialize>(json) ?? new List()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter, string>( + JsonStringReaderWriter.Instance, + new ValueConverter, string>( + (List list) => LcmCrdtDbContext.Serialize(list), + (string json) => string.IsNullOrWhiteSpace(json) ? new List() : LcmCrdtDbContext.Deserialize>(json) ?? new List()))); + publishIn.AddAnnotation("Relational:ColumnType", "jsonb"); + + var snapshotId = runtimeEntityType.AddProperty( + "SnapshotId", + typeof(Guid?), + nullable: true); + snapshotId.TypeMapping = SqliteGuidTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { snapshotId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SnapshotId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.SetNull, + unique: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "Entry"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/ExampleSentenceEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/ExampleSentenceEntityType.cs new file mode 100644 index 0000000000..f509ee77f2 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/ExampleSentenceEntityType.cs @@ -0,0 +1,209 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using MiniLcm.Models; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class ExampleSentenceEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "MiniLcm.Models.ExampleSentence", + typeof(ExampleSentence), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(ExampleSentence).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ExampleSentence).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var deletedAt = runtimeEntityType.AddProperty( + "DeletedAt", + typeof(DateTimeOffset?), + propertyInfo: typeof(ExampleSentence).GetProperty("DeletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ExampleSentence).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + deletedAt.TypeMapping = SqliteDateTimeOffsetTypeMapping.Default; + + var order = runtimeEntityType.AddProperty( + "Order", + typeof(double), + propertyInfo: typeof(ExampleSentence).GetProperty("Order", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ExampleSentence).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0.0); + order.TypeMapping = DoubleTypeMapping.Default.Clone( + comparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + keyComparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + providerValueComparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "REAL")); + + var reference = runtimeEntityType.AddProperty( + "Reference", + typeof(string), + propertyInfo: typeof(ExampleSentence).GetProperty("Reference", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ExampleSentence).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + reference.TypeMapping = SqliteStringTypeMapping.Default; + + var senseId = runtimeEntityType.AddProperty( + "SenseId", + typeof(Guid), + propertyInfo: typeof(ExampleSentence).GetProperty("SenseId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ExampleSentence).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + senseId.TypeMapping = SqliteGuidTypeMapping.Default; + + var sentence = runtimeEntityType.AddProperty( + "Sentence", + typeof(RichMultiString), + propertyInfo: typeof(ExampleSentence).GetProperty("Sentence", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ExampleSentence).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.RichMultiStringDbConverter()); + sentence.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + keyComparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()))); + sentence.AddAnnotation("Relational:ColumnType", "jsonb"); + + var snapshotId = runtimeEntityType.AddProperty( + "SnapshotId", + typeof(Guid?), + nullable: true); + snapshotId.TypeMapping = SqliteGuidTypeMapping.Default; + + var translation = runtimeEntityType.AddProperty( + "Translation", + typeof(RichMultiString), + propertyInfo: typeof(ExampleSentence).GetProperty("Translation", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ExampleSentence).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.RichMultiStringDbConverter()); + translation.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + keyComparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()))); + translation.AddAnnotation("Relational:ColumnType", "jsonb"); + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { senseId }); + + var index0 = runtimeEntityType.AddIndex( + new[] { snapshotId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SenseId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + required: true); + + var exampleSentences = principalEntityType.AddNavigation("ExampleSentences", + runtimeForeignKey, + onDependent: false, + typeof(List), + propertyInfo: typeof(Sense).GetProperty("ExampleSentences", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SnapshotId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.SetNull, + unique: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "ExampleSentence"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModel.cs b/backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModel.cs new file mode 100644 index 0000000000..9437306df8 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModel.cs @@ -0,0 +1,47 @@ +// +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + [DbContext(typeof(LcmCrdtDbContext))] + public partial class LcmCrdtDbContextModel : RuntimeModel + { + private static readonly bool _useOldBehavior31751 = + System.AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue31751", out var enabled31751) && enabled31751; + + static LcmCrdtDbContextModel() + { + var model = new LcmCrdtDbContextModel(); + + if (_useOldBehavior31751) + { + model.Initialize(); + } + else + { + var thread = new System.Threading.Thread(RunInitialization, 10 * 1024 * 1024); + thread.Start(); + thread.Join(); + + void RunInitialization() + { + model.Initialize(); + } + } + + model.Customize(); + _instance = model; + } + + private static LcmCrdtDbContextModel _instance; + public static IModel Instance => _instance; + + partial void Initialize(); + + partial void Customize(); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModelBuilder.cs b/backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModelBuilder.cs new file mode 100644 index 0000000000..49191d9370 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/LcmCrdtDbContextModelBuilder.cs @@ -0,0 +1,1514 @@ +// +using System; +using System.Collections.Generic; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; +using Microsoft.EntityFrameworkCore.Migrations; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + public partial class LcmCrdtDbContextModel + { + partial void Initialize() + { + var projectData = ProjectDataEntityType.Create(this); + var complexFormComponent = ComplexFormComponentEntityType.Create(this); + var complexFormType = ComplexFormTypeEntityType.Create(this); + var entry = EntryEntityType.Create(this); + var exampleSentence = ExampleSentenceEntityType.Create(this); + var partOfSpeech = PartOfSpeechEntityType.Create(this); + var publication = PublicationEntityType.Create(this); + var semanticDomain = SemanticDomainEntityType.Create(this); + var sense = SenseEntityType.Create(this); + var writingSystem = WritingSystemEntityType.Create(this); + var commit = CommitEntityType.Create(this); + var changeEntity = ChangeEntityEntityType.Create(this); + var objectSnapshot = ObjectSnapshotEntityType.Create(this); + + ComplexFormComponentEntityType.CreateForeignKey1(complexFormComponent, entry); + ComplexFormComponentEntityType.CreateForeignKey2(complexFormComponent, entry); + ComplexFormComponentEntityType.CreateForeignKey3(complexFormComponent, sense); + ComplexFormComponentEntityType.CreateForeignKey4(complexFormComponent, objectSnapshot); + ComplexFormTypeEntityType.CreateForeignKey1(complexFormType, objectSnapshot); + EntryEntityType.CreateForeignKey1(entry, objectSnapshot); + ExampleSentenceEntityType.CreateForeignKey1(exampleSentence, sense); + ExampleSentenceEntityType.CreateForeignKey2(exampleSentence, objectSnapshot); + PartOfSpeechEntityType.CreateForeignKey1(partOfSpeech, objectSnapshot); + PublicationEntityType.CreateForeignKey1(publication, objectSnapshot); + SemanticDomainEntityType.CreateForeignKey1(semanticDomain, objectSnapshot); + SenseEntityType.CreateForeignKey1(sense, entry); + SenseEntityType.CreateForeignKey2(sense, partOfSpeech); + SenseEntityType.CreateForeignKey3(sense, objectSnapshot); + WritingSystemEntityType.CreateForeignKey1(writingSystem, objectSnapshot); + ChangeEntityEntityType.CreateForeignKey1(changeEntity, commit); + ObjectSnapshotEntityType.CreateForeignKey1(objectSnapshot, commit); + + ProjectDataEntityType.CreateAnnotations(projectData); + ComplexFormComponentEntityType.CreateAnnotations(complexFormComponent); + ComplexFormTypeEntityType.CreateAnnotations(complexFormType); + EntryEntityType.CreateAnnotations(entry); + ExampleSentenceEntityType.CreateAnnotations(exampleSentence); + PartOfSpeechEntityType.CreateAnnotations(partOfSpeech); + PublicationEntityType.CreateAnnotations(publication); + SemanticDomainEntityType.CreateAnnotations(semanticDomain); + SenseEntityType.CreateAnnotations(sense); + WritingSystemEntityType.CreateAnnotations(writingSystem); + CommitEntityType.CreateAnnotations(commit); + ChangeEntityEntityType.CreateAnnotations(changeEntity); + ObjectSnapshotEntityType.CreateAnnotations(objectSnapshot); + + AddAnnotation("ProductVersion", "8.0.15"); + AddRuntimeAnnotation("Relational:RelationalModel", CreateRelationalModel()); + } + + private IRelationalModel CreateRelationalModel() + { + var relationalModel = new RelationalModel(this); + + var projectData = FindEntityType("LcmCrdt.ProjectData")!; + + var defaultTableMappings = new List>(); + projectData.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings); + var lcmCrdtProjectDataTableBase = new TableBase("LcmCrdt.ProjectData", null, relationalModel); + var clientIdColumnBase = new ColumnBase("ClientId", "TEXT", lcmCrdtProjectDataTableBase); + lcmCrdtProjectDataTableBase.Columns.Add("ClientId", clientIdColumnBase); + var codeColumnBase = new ColumnBase("Code", "TEXT", lcmCrdtProjectDataTableBase); + lcmCrdtProjectDataTableBase.Columns.Add("Code", codeColumnBase); + var fwProjectIdColumnBase = new ColumnBase("FwProjectId", "TEXT", lcmCrdtProjectDataTableBase) + { + IsNullable = true + }; + lcmCrdtProjectDataTableBase.Columns.Add("FwProjectId", fwProjectIdColumnBase); + var idColumnBase = new ColumnBase("Id", "TEXT", lcmCrdtProjectDataTableBase); + lcmCrdtProjectDataTableBase.Columns.Add("Id", idColumnBase); + var lastUserIdColumnBase = new ColumnBase("LastUserId", "TEXT", lcmCrdtProjectDataTableBase) + { + IsNullable = true + }; + lcmCrdtProjectDataTableBase.Columns.Add("LastUserId", lastUserIdColumnBase); + var lastUserNameColumnBase = new ColumnBase("LastUserName", "TEXT", lcmCrdtProjectDataTableBase) + { + IsNullable = true + }; + lcmCrdtProjectDataTableBase.Columns.Add("LastUserName", lastUserNameColumnBase); + var nameColumnBase = new ColumnBase("Name", "TEXT", lcmCrdtProjectDataTableBase); + lcmCrdtProjectDataTableBase.Columns.Add("Name", nameColumnBase); + var originDomainColumnBase = new ColumnBase("OriginDomain", "TEXT", lcmCrdtProjectDataTableBase) + { + IsNullable = true + }; + lcmCrdtProjectDataTableBase.Columns.Add("OriginDomain", originDomainColumnBase); + relationalModel.DefaultTables.Add("LcmCrdt.ProjectData", lcmCrdtProjectDataTableBase); + var lcmCrdtProjectDataMappingBase = new TableMappingBase(projectData, lcmCrdtProjectDataTableBase, true); + lcmCrdtProjectDataTableBase.AddTypeMapping(lcmCrdtProjectDataMappingBase, false); + defaultTableMappings.Add(lcmCrdtProjectDataMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase, projectData.FindProperty("Id")!, lcmCrdtProjectDataMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)clientIdColumnBase, projectData.FindProperty("ClientId")!, lcmCrdtProjectDataMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)codeColumnBase, projectData.FindProperty("Code")!, lcmCrdtProjectDataMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)fwProjectIdColumnBase, projectData.FindProperty("FwProjectId")!, lcmCrdtProjectDataMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)lastUserIdColumnBase, projectData.FindProperty("LastUserId")!, lcmCrdtProjectDataMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)lastUserNameColumnBase, projectData.FindProperty("LastUserName")!, lcmCrdtProjectDataMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)nameColumnBase, projectData.FindProperty("Name")!, lcmCrdtProjectDataMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)originDomainColumnBase, projectData.FindProperty("OriginDomain")!, lcmCrdtProjectDataMappingBase); + + var tableMappings = new List(); + projectData.SetRuntimeAnnotation("Relational:TableMappings", tableMappings); + var projectDataTable = new Table("ProjectData", null, relationalModel); + var idColumn = new Column("Id", "TEXT", projectDataTable); + projectDataTable.Columns.Add("Id", idColumn); + var clientIdColumn = new Column("ClientId", "TEXT", projectDataTable); + projectDataTable.Columns.Add("ClientId", clientIdColumn); + var codeColumn = new Column("Code", "TEXT", projectDataTable); + projectDataTable.Columns.Add("Code", codeColumn); + var fwProjectIdColumn = new Column("FwProjectId", "TEXT", projectDataTable) + { + IsNullable = true + }; + projectDataTable.Columns.Add("FwProjectId", fwProjectIdColumn); + var lastUserIdColumn = new Column("LastUserId", "TEXT", projectDataTable) + { + IsNullable = true + }; + projectDataTable.Columns.Add("LastUserId", lastUserIdColumn); + var lastUserNameColumn = new Column("LastUserName", "TEXT", projectDataTable) + { + IsNullable = true + }; + projectDataTable.Columns.Add("LastUserName", lastUserNameColumn); + var nameColumn = new Column("Name", "TEXT", projectDataTable); + projectDataTable.Columns.Add("Name", nameColumn); + var originDomainColumn = new Column("OriginDomain", "TEXT", projectDataTable) + { + IsNullable = true + }; + projectDataTable.Columns.Add("OriginDomain", originDomainColumn); + var pK_ProjectData = new UniqueConstraint("PK_ProjectData", projectDataTable, new[] { idColumn }); + projectDataTable.PrimaryKey = pK_ProjectData; + var pK_ProjectDataUc = RelationalModel.GetKey(this, + "LcmCrdt.ProjectData", + new[] { "Id" }); + pK_ProjectData.MappedKeys.Add(pK_ProjectDataUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_ProjectDataUc).Add(pK_ProjectData); + projectDataTable.UniqueConstraints.Add("PK_ProjectData", pK_ProjectData); + relationalModel.Tables.Add(("ProjectData", null), projectDataTable); + var projectDataTableMapping = new TableMapping(projectData, projectDataTable, true); + projectDataTable.AddTypeMapping(projectDataTableMapping, false); + tableMappings.Add(projectDataTableMapping); + RelationalModel.CreateColumnMapping(idColumn, projectData.FindProperty("Id")!, projectDataTableMapping); + RelationalModel.CreateColumnMapping(clientIdColumn, projectData.FindProperty("ClientId")!, projectDataTableMapping); + RelationalModel.CreateColumnMapping(codeColumn, projectData.FindProperty("Code")!, projectDataTableMapping); + RelationalModel.CreateColumnMapping(fwProjectIdColumn, projectData.FindProperty("FwProjectId")!, projectDataTableMapping); + RelationalModel.CreateColumnMapping(lastUserIdColumn, projectData.FindProperty("LastUserId")!, projectDataTableMapping); + RelationalModel.CreateColumnMapping(lastUserNameColumn, projectData.FindProperty("LastUserName")!, projectDataTableMapping); + RelationalModel.CreateColumnMapping(nameColumn, projectData.FindProperty("Name")!, projectDataTableMapping); + RelationalModel.CreateColumnMapping(originDomainColumn, projectData.FindProperty("OriginDomain")!, projectDataTableMapping); + + var complexFormComponent = FindEntityType("MiniLcm.Models.ComplexFormComponent")!; + + var defaultTableMappings0 = new List>(); + complexFormComponent.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings0); + var miniLcmModelsComplexFormComponentTableBase = new TableBase("MiniLcm.Models.ComplexFormComponent", null, relationalModel); + var complexFormEntryIdColumnBase = new ColumnBase("ComplexFormEntryId", "TEXT", miniLcmModelsComplexFormComponentTableBase); + miniLcmModelsComplexFormComponentTableBase.Columns.Add("ComplexFormEntryId", complexFormEntryIdColumnBase); + var complexFormHeadwordColumnBase = new ColumnBase("ComplexFormHeadword", "TEXT", miniLcmModelsComplexFormComponentTableBase) + { + IsNullable = true + }; + miniLcmModelsComplexFormComponentTableBase.Columns.Add("ComplexFormHeadword", complexFormHeadwordColumnBase); + var componentEntryIdColumnBase = new ColumnBase("ComponentEntryId", "TEXT", miniLcmModelsComplexFormComponentTableBase); + miniLcmModelsComplexFormComponentTableBase.Columns.Add("ComponentEntryId", componentEntryIdColumnBase); + var componentHeadwordColumnBase = new ColumnBase("ComponentHeadword", "TEXT", miniLcmModelsComplexFormComponentTableBase) + { + IsNullable = true + }; + miniLcmModelsComplexFormComponentTableBase.Columns.Add("ComponentHeadword", componentHeadwordColumnBase); + var componentSenseIdColumnBase = new ColumnBase("ComponentSenseId", "TEXT", miniLcmModelsComplexFormComponentTableBase) + { + IsNullable = true + }; + miniLcmModelsComplexFormComponentTableBase.Columns.Add("ComponentSenseId", componentSenseIdColumnBase); + var deletedAtColumnBase = new ColumnBase("DeletedAt", "TEXT", miniLcmModelsComplexFormComponentTableBase) + { + IsNullable = true + }; + miniLcmModelsComplexFormComponentTableBase.Columns.Add("DeletedAt", deletedAtColumnBase); + var idColumnBase0 = new ColumnBase("Id", "TEXT", miniLcmModelsComplexFormComponentTableBase); + miniLcmModelsComplexFormComponentTableBase.Columns.Add("Id", idColumnBase0); + var orderColumnBase = new ColumnBase("Order", "REAL", miniLcmModelsComplexFormComponentTableBase); + miniLcmModelsComplexFormComponentTableBase.Columns.Add("Order", orderColumnBase); + var snapshotIdColumnBase = new ColumnBase("SnapshotId", "TEXT", miniLcmModelsComplexFormComponentTableBase) + { + IsNullable = true + }; + miniLcmModelsComplexFormComponentTableBase.Columns.Add("SnapshotId", snapshotIdColumnBase); + relationalModel.DefaultTables.Add("MiniLcm.Models.ComplexFormComponent", miniLcmModelsComplexFormComponentTableBase); + var miniLcmModelsComplexFormComponentMappingBase = new TableMappingBase(complexFormComponent, miniLcmModelsComplexFormComponentTableBase, true); + miniLcmModelsComplexFormComponentTableBase.AddTypeMapping(miniLcmModelsComplexFormComponentMappingBase, false); + defaultTableMappings0.Add(miniLcmModelsComplexFormComponentMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase0, complexFormComponent.FindProperty("Id")!, miniLcmModelsComplexFormComponentMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)complexFormEntryIdColumnBase, complexFormComponent.FindProperty("ComplexFormEntryId")!, miniLcmModelsComplexFormComponentMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)complexFormHeadwordColumnBase, complexFormComponent.FindProperty("ComplexFormHeadword")!, miniLcmModelsComplexFormComponentMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)componentEntryIdColumnBase, complexFormComponent.FindProperty("ComponentEntryId")!, miniLcmModelsComplexFormComponentMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)componentHeadwordColumnBase, complexFormComponent.FindProperty("ComponentHeadword")!, miniLcmModelsComplexFormComponentMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)componentSenseIdColumnBase, complexFormComponent.FindProperty("ComponentSenseId")!, miniLcmModelsComplexFormComponentMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)deletedAtColumnBase, complexFormComponent.FindProperty("DeletedAt")!, miniLcmModelsComplexFormComponentMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)orderColumnBase, complexFormComponent.FindProperty("Order")!, miniLcmModelsComplexFormComponentMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)snapshotIdColumnBase, complexFormComponent.FindProperty("SnapshotId")!, miniLcmModelsComplexFormComponentMappingBase); + + var tableMappings0 = new List(); + complexFormComponent.SetRuntimeAnnotation("Relational:TableMappings", tableMappings0); + var complexFormComponentsTable = new Table("ComplexFormComponents", null, relationalModel); + var idColumn0 = new Column("Id", "TEXT", complexFormComponentsTable); + complexFormComponentsTable.Columns.Add("Id", idColumn0); + var complexFormEntryIdColumn = new Column("ComplexFormEntryId", "TEXT", complexFormComponentsTable); + complexFormComponentsTable.Columns.Add("ComplexFormEntryId", complexFormEntryIdColumn); + var complexFormHeadwordColumn = new Column("ComplexFormHeadword", "TEXT", complexFormComponentsTable) + { + IsNullable = true + }; + complexFormComponentsTable.Columns.Add("ComplexFormHeadword", complexFormHeadwordColumn); + var componentEntryIdColumn = new Column("ComponentEntryId", "TEXT", complexFormComponentsTable); + complexFormComponentsTable.Columns.Add("ComponentEntryId", componentEntryIdColumn); + var componentHeadwordColumn = new Column("ComponentHeadword", "TEXT", complexFormComponentsTable) + { + IsNullable = true + }; + complexFormComponentsTable.Columns.Add("ComponentHeadword", componentHeadwordColumn); + var componentSenseIdColumn = new Column("ComponentSenseId", "TEXT", complexFormComponentsTable) + { + IsNullable = true + }; + complexFormComponentsTable.Columns.Add("ComponentSenseId", componentSenseIdColumn); + var deletedAtColumn = new Column("DeletedAt", "TEXT", complexFormComponentsTable) + { + IsNullable = true + }; + complexFormComponentsTable.Columns.Add("DeletedAt", deletedAtColumn); + var orderColumn = new Column("Order", "REAL", complexFormComponentsTable); + complexFormComponentsTable.Columns.Add("Order", orderColumn); + var snapshotIdColumn = new Column("SnapshotId", "TEXT", complexFormComponentsTable) + { + IsNullable = true + }; + complexFormComponentsTable.Columns.Add("SnapshotId", snapshotIdColumn); + var pK_ComplexFormComponents = new UniqueConstraint("PK_ComplexFormComponents", complexFormComponentsTable, new[] { idColumn0 }); + complexFormComponentsTable.PrimaryKey = pK_ComplexFormComponents; + var pK_ComplexFormComponentsUc = RelationalModel.GetKey(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "Id" }); + pK_ComplexFormComponents.MappedKeys.Add(pK_ComplexFormComponentsUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_ComplexFormComponentsUc).Add(pK_ComplexFormComponents); + complexFormComponentsTable.UniqueConstraints.Add("PK_ComplexFormComponents", pK_ComplexFormComponents); + var iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId = new TableIndex( + "IX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId", complexFormComponentsTable, new[] { complexFormEntryIdColumn, componentEntryIdColumn }, true); + var iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "ComplexFormEntryId", "ComponentEntryId" }); + iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId.MappedIndexes.Add(iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryIdIx).Add(iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId); + complexFormComponentsTable.Indexes.Add("IX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId", iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId); + var iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId_ComponentSenseId = new TableIndex( + "IX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId_ComponentSenseId", complexFormComponentsTable, new[] { complexFormEntryIdColumn, componentEntryIdColumn, componentSenseIdColumn }, true); + var iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId_ComponentSenseIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "ComplexFormEntryId", "ComponentEntryId", "ComponentSenseId" }); + iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId_ComponentSenseId.MappedIndexes.Add(iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId_ComponentSenseIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId_ComponentSenseIdIx).Add(iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId_ComponentSenseId); + complexFormComponentsTable.Indexes.Add("IX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId_ComponentSenseId", iX_ComplexFormComponents_ComplexFormEntryId_ComponentEntryId_ComponentSenseId); + var iX_ComplexFormComponents_ComponentEntryId = new TableIndex( + "IX_ComplexFormComponents_ComponentEntryId", complexFormComponentsTable, new[] { componentEntryIdColumn }, false); + var iX_ComplexFormComponents_ComponentEntryIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "ComponentEntryId" }); + iX_ComplexFormComponents_ComponentEntryId.MappedIndexes.Add(iX_ComplexFormComponents_ComponentEntryIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_ComplexFormComponents_ComponentEntryIdIx).Add(iX_ComplexFormComponents_ComponentEntryId); + complexFormComponentsTable.Indexes.Add("IX_ComplexFormComponents_ComponentEntryId", iX_ComplexFormComponents_ComponentEntryId); + var iX_ComplexFormComponents_ComponentSenseId = new TableIndex( + "IX_ComplexFormComponents_ComponentSenseId", complexFormComponentsTable, new[] { componentSenseIdColumn }, false); + var iX_ComplexFormComponents_ComponentSenseIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "ComponentSenseId" }); + iX_ComplexFormComponents_ComponentSenseId.MappedIndexes.Add(iX_ComplexFormComponents_ComponentSenseIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_ComplexFormComponents_ComponentSenseIdIx).Add(iX_ComplexFormComponents_ComponentSenseId); + complexFormComponentsTable.Indexes.Add("IX_ComplexFormComponents_ComponentSenseId", iX_ComplexFormComponents_ComponentSenseId); + var iX_ComplexFormComponents_SnapshotId = new TableIndex( + "IX_ComplexFormComponents_SnapshotId", complexFormComponentsTable, new[] { snapshotIdColumn }, true); + var iX_ComplexFormComponents_SnapshotIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "SnapshotId" }); + iX_ComplexFormComponents_SnapshotId.MappedIndexes.Add(iX_ComplexFormComponents_SnapshotIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_ComplexFormComponents_SnapshotIdIx).Add(iX_ComplexFormComponents_SnapshotId); + complexFormComponentsTable.Indexes.Add("IX_ComplexFormComponents_SnapshotId", iX_ComplexFormComponents_SnapshotId); + relationalModel.Tables.Add(("ComplexFormComponents", null), complexFormComponentsTable); + var complexFormComponentsTableMapping = new TableMapping(complexFormComponent, complexFormComponentsTable, true); + complexFormComponentsTable.AddTypeMapping(complexFormComponentsTableMapping, false); + tableMappings0.Add(complexFormComponentsTableMapping); + RelationalModel.CreateColumnMapping(idColumn0, complexFormComponent.FindProperty("Id")!, complexFormComponentsTableMapping); + RelationalModel.CreateColumnMapping(complexFormEntryIdColumn, complexFormComponent.FindProperty("ComplexFormEntryId")!, complexFormComponentsTableMapping); + RelationalModel.CreateColumnMapping(complexFormHeadwordColumn, complexFormComponent.FindProperty("ComplexFormHeadword")!, complexFormComponentsTableMapping); + RelationalModel.CreateColumnMapping(componentEntryIdColumn, complexFormComponent.FindProperty("ComponentEntryId")!, complexFormComponentsTableMapping); + RelationalModel.CreateColumnMapping(componentHeadwordColumn, complexFormComponent.FindProperty("ComponentHeadword")!, complexFormComponentsTableMapping); + RelationalModel.CreateColumnMapping(componentSenseIdColumn, complexFormComponent.FindProperty("ComponentSenseId")!, complexFormComponentsTableMapping); + RelationalModel.CreateColumnMapping(deletedAtColumn, complexFormComponent.FindProperty("DeletedAt")!, complexFormComponentsTableMapping); + RelationalModel.CreateColumnMapping(orderColumn, complexFormComponent.FindProperty("Order")!, complexFormComponentsTableMapping); + RelationalModel.CreateColumnMapping(snapshotIdColumn, complexFormComponent.FindProperty("SnapshotId")!, complexFormComponentsTableMapping); + + var complexFormType = FindEntityType("MiniLcm.Models.ComplexFormType")!; + + var defaultTableMappings1 = new List>(); + complexFormType.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings1); + var miniLcmModelsComplexFormTypeTableBase = new TableBase("MiniLcm.Models.ComplexFormType", null, relationalModel); + var deletedAtColumnBase0 = new ColumnBase("DeletedAt", "TEXT", miniLcmModelsComplexFormTypeTableBase) + { + IsNullable = true + }; + miniLcmModelsComplexFormTypeTableBase.Columns.Add("DeletedAt", deletedAtColumnBase0); + var idColumnBase1 = new ColumnBase("Id", "TEXT", miniLcmModelsComplexFormTypeTableBase); + miniLcmModelsComplexFormTypeTableBase.Columns.Add("Id", idColumnBase1); + var nameColumnBase0 = new ColumnBase("Name", "jsonb", miniLcmModelsComplexFormTypeTableBase); + miniLcmModelsComplexFormTypeTableBase.Columns.Add("Name", nameColumnBase0); + var snapshotIdColumnBase0 = new ColumnBase("SnapshotId", "TEXT", miniLcmModelsComplexFormTypeTableBase) + { + IsNullable = true + }; + miniLcmModelsComplexFormTypeTableBase.Columns.Add("SnapshotId", snapshotIdColumnBase0); + relationalModel.DefaultTables.Add("MiniLcm.Models.ComplexFormType", miniLcmModelsComplexFormTypeTableBase); + var miniLcmModelsComplexFormTypeMappingBase = new TableMappingBase(complexFormType, miniLcmModelsComplexFormTypeTableBase, true); + miniLcmModelsComplexFormTypeTableBase.AddTypeMapping(miniLcmModelsComplexFormTypeMappingBase, false); + defaultTableMappings1.Add(miniLcmModelsComplexFormTypeMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase1, complexFormType.FindProperty("Id")!, miniLcmModelsComplexFormTypeMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)deletedAtColumnBase0, complexFormType.FindProperty("DeletedAt")!, miniLcmModelsComplexFormTypeMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)nameColumnBase0, complexFormType.FindProperty("Name")!, miniLcmModelsComplexFormTypeMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)snapshotIdColumnBase0, complexFormType.FindProperty("SnapshotId")!, miniLcmModelsComplexFormTypeMappingBase); + + var tableMappings1 = new List(); + complexFormType.SetRuntimeAnnotation("Relational:TableMappings", tableMappings1); + var complexFormTypeTable = new Table("ComplexFormType", null, relationalModel); + var idColumn1 = new Column("Id", "TEXT", complexFormTypeTable); + complexFormTypeTable.Columns.Add("Id", idColumn1); + var deletedAtColumn0 = new Column("DeletedAt", "TEXT", complexFormTypeTable) + { + IsNullable = true + }; + complexFormTypeTable.Columns.Add("DeletedAt", deletedAtColumn0); + var nameColumn0 = new Column("Name", "jsonb", complexFormTypeTable); + complexFormTypeTable.Columns.Add("Name", nameColumn0); + var snapshotIdColumn0 = new Column("SnapshotId", "TEXT", complexFormTypeTable) + { + IsNullable = true + }; + complexFormTypeTable.Columns.Add("SnapshotId", snapshotIdColumn0); + var pK_ComplexFormType = new UniqueConstraint("PK_ComplexFormType", complexFormTypeTable, new[] { idColumn1 }); + complexFormTypeTable.PrimaryKey = pK_ComplexFormType; + var pK_ComplexFormTypeUc = RelationalModel.GetKey(this, + "MiniLcm.Models.ComplexFormType", + new[] { "Id" }); + pK_ComplexFormType.MappedKeys.Add(pK_ComplexFormTypeUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_ComplexFormTypeUc).Add(pK_ComplexFormType); + complexFormTypeTable.UniqueConstraints.Add("PK_ComplexFormType", pK_ComplexFormType); + var iX_ComplexFormType_SnapshotId = new TableIndex( + "IX_ComplexFormType_SnapshotId", complexFormTypeTable, new[] { snapshotIdColumn0 }, true); + var iX_ComplexFormType_SnapshotIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.ComplexFormType", + new[] { "SnapshotId" }); + iX_ComplexFormType_SnapshotId.MappedIndexes.Add(iX_ComplexFormType_SnapshotIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_ComplexFormType_SnapshotIdIx).Add(iX_ComplexFormType_SnapshotId); + complexFormTypeTable.Indexes.Add("IX_ComplexFormType_SnapshotId", iX_ComplexFormType_SnapshotId); + relationalModel.Tables.Add(("ComplexFormType", null), complexFormTypeTable); + var complexFormTypeTableMapping = new TableMapping(complexFormType, complexFormTypeTable, true); + complexFormTypeTable.AddTypeMapping(complexFormTypeTableMapping, false); + tableMappings1.Add(complexFormTypeTableMapping); + RelationalModel.CreateColumnMapping(idColumn1, complexFormType.FindProperty("Id")!, complexFormTypeTableMapping); + RelationalModel.CreateColumnMapping(deletedAtColumn0, complexFormType.FindProperty("DeletedAt")!, complexFormTypeTableMapping); + RelationalModel.CreateColumnMapping(nameColumn0, complexFormType.FindProperty("Name")!, complexFormTypeTableMapping); + RelationalModel.CreateColumnMapping(snapshotIdColumn0, complexFormType.FindProperty("SnapshotId")!, complexFormTypeTableMapping); + + var entry = FindEntityType("MiniLcm.Models.Entry")!; + + var defaultTableMappings2 = new List>(); + entry.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings2); + var miniLcmModelsEntryTableBase = new TableBase("MiniLcm.Models.Entry", null, relationalModel); + var citationFormColumnBase = new ColumnBase("CitationForm", "jsonb", miniLcmModelsEntryTableBase); + miniLcmModelsEntryTableBase.Columns.Add("CitationForm", citationFormColumnBase); + var complexFormTypesColumnBase = new ColumnBase("ComplexFormTypes", "jsonb", miniLcmModelsEntryTableBase); + miniLcmModelsEntryTableBase.Columns.Add("ComplexFormTypes", complexFormTypesColumnBase); + var deletedAtColumnBase1 = new ColumnBase("DeletedAt", "TEXT", miniLcmModelsEntryTableBase) + { + IsNullable = true + }; + miniLcmModelsEntryTableBase.Columns.Add("DeletedAt", deletedAtColumnBase1); + var idColumnBase2 = new ColumnBase("Id", "TEXT", miniLcmModelsEntryTableBase); + miniLcmModelsEntryTableBase.Columns.Add("Id", idColumnBase2); + var lexemeFormColumnBase = new ColumnBase("LexemeForm", "jsonb", miniLcmModelsEntryTableBase); + miniLcmModelsEntryTableBase.Columns.Add("LexemeForm", lexemeFormColumnBase); + var literalMeaningColumnBase = new ColumnBase("LiteralMeaning", "jsonb", miniLcmModelsEntryTableBase); + miniLcmModelsEntryTableBase.Columns.Add("LiteralMeaning", literalMeaningColumnBase); + var noteColumnBase = new ColumnBase("Note", "jsonb", miniLcmModelsEntryTableBase); + miniLcmModelsEntryTableBase.Columns.Add("Note", noteColumnBase); + var publishInColumnBase = new ColumnBase("PublishIn", "jsonb", miniLcmModelsEntryTableBase); + miniLcmModelsEntryTableBase.Columns.Add("PublishIn", publishInColumnBase); + var snapshotIdColumnBase1 = new ColumnBase("SnapshotId", "TEXT", miniLcmModelsEntryTableBase) + { + IsNullable = true + }; + miniLcmModelsEntryTableBase.Columns.Add("SnapshotId", snapshotIdColumnBase1); + relationalModel.DefaultTables.Add("MiniLcm.Models.Entry", miniLcmModelsEntryTableBase); + var miniLcmModelsEntryMappingBase = new TableMappingBase(entry, miniLcmModelsEntryTableBase, true); + miniLcmModelsEntryTableBase.AddTypeMapping(miniLcmModelsEntryMappingBase, false); + defaultTableMappings2.Add(miniLcmModelsEntryMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase2, entry.FindProperty("Id")!, miniLcmModelsEntryMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)citationFormColumnBase, entry.FindProperty("CitationForm")!, miniLcmModelsEntryMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)complexFormTypesColumnBase, entry.FindProperty("ComplexFormTypes")!, miniLcmModelsEntryMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)deletedAtColumnBase1, entry.FindProperty("DeletedAt")!, miniLcmModelsEntryMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)lexemeFormColumnBase, entry.FindProperty("LexemeForm")!, miniLcmModelsEntryMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)literalMeaningColumnBase, entry.FindProperty("LiteralMeaning")!, miniLcmModelsEntryMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)noteColumnBase, entry.FindProperty("Note")!, miniLcmModelsEntryMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)publishInColumnBase, entry.FindProperty("PublishIn")!, miniLcmModelsEntryMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)snapshotIdColumnBase1, entry.FindProperty("SnapshotId")!, miniLcmModelsEntryMappingBase); + + var tableMappings2 = new List(); + entry.SetRuntimeAnnotation("Relational:TableMappings", tableMappings2); + var entryTable = new Table("Entry", null, relationalModel); + var idColumn2 = new Column("Id", "TEXT", entryTable); + entryTable.Columns.Add("Id", idColumn2); + var citationFormColumn = new Column("CitationForm", "jsonb", entryTable); + entryTable.Columns.Add("CitationForm", citationFormColumn); + var complexFormTypesColumn = new Column("ComplexFormTypes", "jsonb", entryTable); + entryTable.Columns.Add("ComplexFormTypes", complexFormTypesColumn); + var deletedAtColumn1 = new Column("DeletedAt", "TEXT", entryTable) + { + IsNullable = true + }; + entryTable.Columns.Add("DeletedAt", deletedAtColumn1); + var lexemeFormColumn = new Column("LexemeForm", "jsonb", entryTable); + entryTable.Columns.Add("LexemeForm", lexemeFormColumn); + var literalMeaningColumn = new Column("LiteralMeaning", "jsonb", entryTable); + entryTable.Columns.Add("LiteralMeaning", literalMeaningColumn); + var noteColumn = new Column("Note", "jsonb", entryTable); + entryTable.Columns.Add("Note", noteColumn); + var publishInColumn = new Column("PublishIn", "jsonb", entryTable); + entryTable.Columns.Add("PublishIn", publishInColumn); + var snapshotIdColumn1 = new Column("SnapshotId", "TEXT", entryTable) + { + IsNullable = true + }; + entryTable.Columns.Add("SnapshotId", snapshotIdColumn1); + var pK_Entry = new UniqueConstraint("PK_Entry", entryTable, new[] { idColumn2 }); + entryTable.PrimaryKey = pK_Entry; + var pK_EntryUc = RelationalModel.GetKey(this, + "MiniLcm.Models.Entry", + new[] { "Id" }); + pK_Entry.MappedKeys.Add(pK_EntryUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_EntryUc).Add(pK_Entry); + entryTable.UniqueConstraints.Add("PK_Entry", pK_Entry); + var iX_Entry_SnapshotId = new TableIndex( + "IX_Entry_SnapshotId", entryTable, new[] { snapshotIdColumn1 }, true); + var iX_Entry_SnapshotIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.Entry", + new[] { "SnapshotId" }); + iX_Entry_SnapshotId.MappedIndexes.Add(iX_Entry_SnapshotIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_Entry_SnapshotIdIx).Add(iX_Entry_SnapshotId); + entryTable.Indexes.Add("IX_Entry_SnapshotId", iX_Entry_SnapshotId); + relationalModel.Tables.Add(("Entry", null), entryTable); + var entryTableMapping = new TableMapping(entry, entryTable, true); + entryTable.AddTypeMapping(entryTableMapping, false); + tableMappings2.Add(entryTableMapping); + RelationalModel.CreateColumnMapping(idColumn2, entry.FindProperty("Id")!, entryTableMapping); + RelationalModel.CreateColumnMapping(citationFormColumn, entry.FindProperty("CitationForm")!, entryTableMapping); + RelationalModel.CreateColumnMapping(complexFormTypesColumn, entry.FindProperty("ComplexFormTypes")!, entryTableMapping); + RelationalModel.CreateColumnMapping(deletedAtColumn1, entry.FindProperty("DeletedAt")!, entryTableMapping); + RelationalModel.CreateColumnMapping(lexemeFormColumn, entry.FindProperty("LexemeForm")!, entryTableMapping); + RelationalModel.CreateColumnMapping(literalMeaningColumn, entry.FindProperty("LiteralMeaning")!, entryTableMapping); + RelationalModel.CreateColumnMapping(noteColumn, entry.FindProperty("Note")!, entryTableMapping); + RelationalModel.CreateColumnMapping(publishInColumn, entry.FindProperty("PublishIn")!, entryTableMapping); + RelationalModel.CreateColumnMapping(snapshotIdColumn1, entry.FindProperty("SnapshotId")!, entryTableMapping); + + var exampleSentence = FindEntityType("MiniLcm.Models.ExampleSentence")!; + + var defaultTableMappings3 = new List>(); + exampleSentence.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings3); + var miniLcmModelsExampleSentenceTableBase = new TableBase("MiniLcm.Models.ExampleSentence", null, relationalModel); + var deletedAtColumnBase2 = new ColumnBase("DeletedAt", "TEXT", miniLcmModelsExampleSentenceTableBase) + { + IsNullable = true + }; + miniLcmModelsExampleSentenceTableBase.Columns.Add("DeletedAt", deletedAtColumnBase2); + var idColumnBase3 = new ColumnBase("Id", "TEXT", miniLcmModelsExampleSentenceTableBase); + miniLcmModelsExampleSentenceTableBase.Columns.Add("Id", idColumnBase3); + var orderColumnBase0 = new ColumnBase("Order", "REAL", miniLcmModelsExampleSentenceTableBase); + miniLcmModelsExampleSentenceTableBase.Columns.Add("Order", orderColumnBase0); + var referenceColumnBase = new ColumnBase("Reference", "TEXT", miniLcmModelsExampleSentenceTableBase) + { + IsNullable = true + }; + miniLcmModelsExampleSentenceTableBase.Columns.Add("Reference", referenceColumnBase); + var senseIdColumnBase = new ColumnBase("SenseId", "TEXT", miniLcmModelsExampleSentenceTableBase); + miniLcmModelsExampleSentenceTableBase.Columns.Add("SenseId", senseIdColumnBase); + var sentenceColumnBase = new ColumnBase("Sentence", "jsonb", miniLcmModelsExampleSentenceTableBase); + miniLcmModelsExampleSentenceTableBase.Columns.Add("Sentence", sentenceColumnBase); + var snapshotIdColumnBase2 = new ColumnBase("SnapshotId", "TEXT", miniLcmModelsExampleSentenceTableBase) + { + IsNullable = true + }; + miniLcmModelsExampleSentenceTableBase.Columns.Add("SnapshotId", snapshotIdColumnBase2); + var translationColumnBase = new ColumnBase("Translation", "jsonb", miniLcmModelsExampleSentenceTableBase); + miniLcmModelsExampleSentenceTableBase.Columns.Add("Translation", translationColumnBase); + relationalModel.DefaultTables.Add("MiniLcm.Models.ExampleSentence", miniLcmModelsExampleSentenceTableBase); + var miniLcmModelsExampleSentenceMappingBase = new TableMappingBase(exampleSentence, miniLcmModelsExampleSentenceTableBase, true); + miniLcmModelsExampleSentenceTableBase.AddTypeMapping(miniLcmModelsExampleSentenceMappingBase, false); + defaultTableMappings3.Add(miniLcmModelsExampleSentenceMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase3, exampleSentence.FindProperty("Id")!, miniLcmModelsExampleSentenceMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)deletedAtColumnBase2, exampleSentence.FindProperty("DeletedAt")!, miniLcmModelsExampleSentenceMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)orderColumnBase0, exampleSentence.FindProperty("Order")!, miniLcmModelsExampleSentenceMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)referenceColumnBase, exampleSentence.FindProperty("Reference")!, miniLcmModelsExampleSentenceMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)senseIdColumnBase, exampleSentence.FindProperty("SenseId")!, miniLcmModelsExampleSentenceMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)sentenceColumnBase, exampleSentence.FindProperty("Sentence")!, miniLcmModelsExampleSentenceMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)snapshotIdColumnBase2, exampleSentence.FindProperty("SnapshotId")!, miniLcmModelsExampleSentenceMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)translationColumnBase, exampleSentence.FindProperty("Translation")!, miniLcmModelsExampleSentenceMappingBase); + + var tableMappings3 = new List(); + exampleSentence.SetRuntimeAnnotation("Relational:TableMappings", tableMappings3); + var exampleSentenceTable = new Table("ExampleSentence", null, relationalModel); + var idColumn3 = new Column("Id", "TEXT", exampleSentenceTable); + exampleSentenceTable.Columns.Add("Id", idColumn3); + var deletedAtColumn2 = new Column("DeletedAt", "TEXT", exampleSentenceTable) + { + IsNullable = true + }; + exampleSentenceTable.Columns.Add("DeletedAt", deletedAtColumn2); + var orderColumn0 = new Column("Order", "REAL", exampleSentenceTable); + exampleSentenceTable.Columns.Add("Order", orderColumn0); + var referenceColumn = new Column("Reference", "TEXT", exampleSentenceTable) + { + IsNullable = true + }; + exampleSentenceTable.Columns.Add("Reference", referenceColumn); + var senseIdColumn = new Column("SenseId", "TEXT", exampleSentenceTable); + exampleSentenceTable.Columns.Add("SenseId", senseIdColumn); + var sentenceColumn = new Column("Sentence", "jsonb", exampleSentenceTable); + exampleSentenceTable.Columns.Add("Sentence", sentenceColumn); + var snapshotIdColumn2 = new Column("SnapshotId", "TEXT", exampleSentenceTable) + { + IsNullable = true + }; + exampleSentenceTable.Columns.Add("SnapshotId", snapshotIdColumn2); + var translationColumn = new Column("Translation", "jsonb", exampleSentenceTable); + exampleSentenceTable.Columns.Add("Translation", translationColumn); + var pK_ExampleSentence = new UniqueConstraint("PK_ExampleSentence", exampleSentenceTable, new[] { idColumn3 }); + exampleSentenceTable.PrimaryKey = pK_ExampleSentence; + var pK_ExampleSentenceUc = RelationalModel.GetKey(this, + "MiniLcm.Models.ExampleSentence", + new[] { "Id" }); + pK_ExampleSentence.MappedKeys.Add(pK_ExampleSentenceUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_ExampleSentenceUc).Add(pK_ExampleSentence); + exampleSentenceTable.UniqueConstraints.Add("PK_ExampleSentence", pK_ExampleSentence); + var iX_ExampleSentence_SenseId = new TableIndex( + "IX_ExampleSentence_SenseId", exampleSentenceTable, new[] { senseIdColumn }, false); + var iX_ExampleSentence_SenseIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.ExampleSentence", + new[] { "SenseId" }); + iX_ExampleSentence_SenseId.MappedIndexes.Add(iX_ExampleSentence_SenseIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_ExampleSentence_SenseIdIx).Add(iX_ExampleSentence_SenseId); + exampleSentenceTable.Indexes.Add("IX_ExampleSentence_SenseId", iX_ExampleSentence_SenseId); + var iX_ExampleSentence_SnapshotId = new TableIndex( + "IX_ExampleSentence_SnapshotId", exampleSentenceTable, new[] { snapshotIdColumn2 }, true); + var iX_ExampleSentence_SnapshotIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.ExampleSentence", + new[] { "SnapshotId" }); + iX_ExampleSentence_SnapshotId.MappedIndexes.Add(iX_ExampleSentence_SnapshotIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_ExampleSentence_SnapshotIdIx).Add(iX_ExampleSentence_SnapshotId); + exampleSentenceTable.Indexes.Add("IX_ExampleSentence_SnapshotId", iX_ExampleSentence_SnapshotId); + relationalModel.Tables.Add(("ExampleSentence", null), exampleSentenceTable); + var exampleSentenceTableMapping = new TableMapping(exampleSentence, exampleSentenceTable, true); + exampleSentenceTable.AddTypeMapping(exampleSentenceTableMapping, false); + tableMappings3.Add(exampleSentenceTableMapping); + RelationalModel.CreateColumnMapping(idColumn3, exampleSentence.FindProperty("Id")!, exampleSentenceTableMapping); + RelationalModel.CreateColumnMapping(deletedAtColumn2, exampleSentence.FindProperty("DeletedAt")!, exampleSentenceTableMapping); + RelationalModel.CreateColumnMapping(orderColumn0, exampleSentence.FindProperty("Order")!, exampleSentenceTableMapping); + RelationalModel.CreateColumnMapping(referenceColumn, exampleSentence.FindProperty("Reference")!, exampleSentenceTableMapping); + RelationalModel.CreateColumnMapping(senseIdColumn, exampleSentence.FindProperty("SenseId")!, exampleSentenceTableMapping); + RelationalModel.CreateColumnMapping(sentenceColumn, exampleSentence.FindProperty("Sentence")!, exampleSentenceTableMapping); + RelationalModel.CreateColumnMapping(snapshotIdColumn2, exampleSentence.FindProperty("SnapshotId")!, exampleSentenceTableMapping); + RelationalModel.CreateColumnMapping(translationColumn, exampleSentence.FindProperty("Translation")!, exampleSentenceTableMapping); + + var partOfSpeech = FindEntityType("MiniLcm.Models.PartOfSpeech")!; + + var defaultTableMappings4 = new List>(); + partOfSpeech.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings4); + var miniLcmModelsPartOfSpeechTableBase = new TableBase("MiniLcm.Models.PartOfSpeech", null, relationalModel); + var deletedAtColumnBase3 = new ColumnBase("DeletedAt", "TEXT", miniLcmModelsPartOfSpeechTableBase) + { + IsNullable = true + }; + miniLcmModelsPartOfSpeechTableBase.Columns.Add("DeletedAt", deletedAtColumnBase3); + var idColumnBase4 = new ColumnBase("Id", "TEXT", miniLcmModelsPartOfSpeechTableBase); + miniLcmModelsPartOfSpeechTableBase.Columns.Add("Id", idColumnBase4); + var nameColumnBase1 = new ColumnBase("Name", "jsonb", miniLcmModelsPartOfSpeechTableBase); + miniLcmModelsPartOfSpeechTableBase.Columns.Add("Name", nameColumnBase1); + var predefinedColumnBase = new ColumnBase("Predefined", "INTEGER", miniLcmModelsPartOfSpeechTableBase); + miniLcmModelsPartOfSpeechTableBase.Columns.Add("Predefined", predefinedColumnBase); + var snapshotIdColumnBase3 = new ColumnBase("SnapshotId", "TEXT", miniLcmModelsPartOfSpeechTableBase) + { + IsNullable = true + }; + miniLcmModelsPartOfSpeechTableBase.Columns.Add("SnapshotId", snapshotIdColumnBase3); + relationalModel.DefaultTables.Add("MiniLcm.Models.PartOfSpeech", miniLcmModelsPartOfSpeechTableBase); + var miniLcmModelsPartOfSpeechMappingBase = new TableMappingBase(partOfSpeech, miniLcmModelsPartOfSpeechTableBase, true); + miniLcmModelsPartOfSpeechTableBase.AddTypeMapping(miniLcmModelsPartOfSpeechMappingBase, false); + defaultTableMappings4.Add(miniLcmModelsPartOfSpeechMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase4, partOfSpeech.FindProperty("Id")!, miniLcmModelsPartOfSpeechMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)deletedAtColumnBase3, partOfSpeech.FindProperty("DeletedAt")!, miniLcmModelsPartOfSpeechMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)nameColumnBase1, partOfSpeech.FindProperty("Name")!, miniLcmModelsPartOfSpeechMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)predefinedColumnBase, partOfSpeech.FindProperty("Predefined")!, miniLcmModelsPartOfSpeechMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)snapshotIdColumnBase3, partOfSpeech.FindProperty("SnapshotId")!, miniLcmModelsPartOfSpeechMappingBase); + + var tableMappings4 = new List(); + partOfSpeech.SetRuntimeAnnotation("Relational:TableMappings", tableMappings4); + var partOfSpeechTable = new Table("PartOfSpeech", null, relationalModel); + var idColumn4 = new Column("Id", "TEXT", partOfSpeechTable); + partOfSpeechTable.Columns.Add("Id", idColumn4); + var deletedAtColumn3 = new Column("DeletedAt", "TEXT", partOfSpeechTable) + { + IsNullable = true + }; + partOfSpeechTable.Columns.Add("DeletedAt", deletedAtColumn3); + var nameColumn1 = new Column("Name", "jsonb", partOfSpeechTable); + partOfSpeechTable.Columns.Add("Name", nameColumn1); + var predefinedColumn = new Column("Predefined", "INTEGER", partOfSpeechTable); + partOfSpeechTable.Columns.Add("Predefined", predefinedColumn); + var snapshotIdColumn3 = new Column("SnapshotId", "TEXT", partOfSpeechTable) + { + IsNullable = true + }; + partOfSpeechTable.Columns.Add("SnapshotId", snapshotIdColumn3); + var pK_PartOfSpeech = new UniqueConstraint("PK_PartOfSpeech", partOfSpeechTable, new[] { idColumn4 }); + partOfSpeechTable.PrimaryKey = pK_PartOfSpeech; + var pK_PartOfSpeechUc = RelationalModel.GetKey(this, + "MiniLcm.Models.PartOfSpeech", + new[] { "Id" }); + pK_PartOfSpeech.MappedKeys.Add(pK_PartOfSpeechUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_PartOfSpeechUc).Add(pK_PartOfSpeech); + partOfSpeechTable.UniqueConstraints.Add("PK_PartOfSpeech", pK_PartOfSpeech); + var iX_PartOfSpeech_SnapshotId = new TableIndex( + "IX_PartOfSpeech_SnapshotId", partOfSpeechTable, new[] { snapshotIdColumn3 }, true); + var iX_PartOfSpeech_SnapshotIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.PartOfSpeech", + new[] { "SnapshotId" }); + iX_PartOfSpeech_SnapshotId.MappedIndexes.Add(iX_PartOfSpeech_SnapshotIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_PartOfSpeech_SnapshotIdIx).Add(iX_PartOfSpeech_SnapshotId); + partOfSpeechTable.Indexes.Add("IX_PartOfSpeech_SnapshotId", iX_PartOfSpeech_SnapshotId); + relationalModel.Tables.Add(("PartOfSpeech", null), partOfSpeechTable); + var partOfSpeechTableMapping = new TableMapping(partOfSpeech, partOfSpeechTable, true); + partOfSpeechTable.AddTypeMapping(partOfSpeechTableMapping, false); + tableMappings4.Add(partOfSpeechTableMapping); + RelationalModel.CreateColumnMapping(idColumn4, partOfSpeech.FindProperty("Id")!, partOfSpeechTableMapping); + RelationalModel.CreateColumnMapping(deletedAtColumn3, partOfSpeech.FindProperty("DeletedAt")!, partOfSpeechTableMapping); + RelationalModel.CreateColumnMapping(nameColumn1, partOfSpeech.FindProperty("Name")!, partOfSpeechTableMapping); + RelationalModel.CreateColumnMapping(predefinedColumn, partOfSpeech.FindProperty("Predefined")!, partOfSpeechTableMapping); + RelationalModel.CreateColumnMapping(snapshotIdColumn3, partOfSpeech.FindProperty("SnapshotId")!, partOfSpeechTableMapping); + + var publication = FindEntityType("MiniLcm.Models.Publication")!; + + var defaultTableMappings5 = new List>(); + publication.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings5); + var miniLcmModelsPublicationTableBase = new TableBase("MiniLcm.Models.Publication", null, relationalModel); + var deletedAtColumnBase4 = new ColumnBase("DeletedAt", "TEXT", miniLcmModelsPublicationTableBase) + { + IsNullable = true + }; + miniLcmModelsPublicationTableBase.Columns.Add("DeletedAt", deletedAtColumnBase4); + var idColumnBase5 = new ColumnBase("Id", "TEXT", miniLcmModelsPublicationTableBase); + miniLcmModelsPublicationTableBase.Columns.Add("Id", idColumnBase5); + var nameColumnBase2 = new ColumnBase("Name", "jsonb", miniLcmModelsPublicationTableBase); + miniLcmModelsPublicationTableBase.Columns.Add("Name", nameColumnBase2); + var snapshotIdColumnBase4 = new ColumnBase("SnapshotId", "TEXT", miniLcmModelsPublicationTableBase) + { + IsNullable = true + }; + miniLcmModelsPublicationTableBase.Columns.Add("SnapshotId", snapshotIdColumnBase4); + relationalModel.DefaultTables.Add("MiniLcm.Models.Publication", miniLcmModelsPublicationTableBase); + var miniLcmModelsPublicationMappingBase = new TableMappingBase(publication, miniLcmModelsPublicationTableBase, true); + miniLcmModelsPublicationTableBase.AddTypeMapping(miniLcmModelsPublicationMappingBase, false); + defaultTableMappings5.Add(miniLcmModelsPublicationMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase5, publication.FindProperty("Id")!, miniLcmModelsPublicationMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)deletedAtColumnBase4, publication.FindProperty("DeletedAt")!, miniLcmModelsPublicationMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)nameColumnBase2, publication.FindProperty("Name")!, miniLcmModelsPublicationMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)snapshotIdColumnBase4, publication.FindProperty("SnapshotId")!, miniLcmModelsPublicationMappingBase); + + var tableMappings5 = new List(); + publication.SetRuntimeAnnotation("Relational:TableMappings", tableMappings5); + var publicationTable = new Table("Publication", null, relationalModel); + var idColumn5 = new Column("Id", "TEXT", publicationTable); + publicationTable.Columns.Add("Id", idColumn5); + var deletedAtColumn4 = new Column("DeletedAt", "TEXT", publicationTable) + { + IsNullable = true + }; + publicationTable.Columns.Add("DeletedAt", deletedAtColumn4); + var nameColumn2 = new Column("Name", "jsonb", publicationTable); + publicationTable.Columns.Add("Name", nameColumn2); + var snapshotIdColumn4 = new Column("SnapshotId", "TEXT", publicationTable) + { + IsNullable = true + }; + publicationTable.Columns.Add("SnapshotId", snapshotIdColumn4); + var pK_Publication = new UniqueConstraint("PK_Publication", publicationTable, new[] { idColumn5 }); + publicationTable.PrimaryKey = pK_Publication; + var pK_PublicationUc = RelationalModel.GetKey(this, + "MiniLcm.Models.Publication", + new[] { "Id" }); + pK_Publication.MappedKeys.Add(pK_PublicationUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_PublicationUc).Add(pK_Publication); + publicationTable.UniqueConstraints.Add("PK_Publication", pK_Publication); + var iX_Publication_SnapshotId = new TableIndex( + "IX_Publication_SnapshotId", publicationTable, new[] { snapshotIdColumn4 }, true); + var iX_Publication_SnapshotIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.Publication", + new[] { "SnapshotId" }); + iX_Publication_SnapshotId.MappedIndexes.Add(iX_Publication_SnapshotIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_Publication_SnapshotIdIx).Add(iX_Publication_SnapshotId); + publicationTable.Indexes.Add("IX_Publication_SnapshotId", iX_Publication_SnapshotId); + relationalModel.Tables.Add(("Publication", null), publicationTable); + var publicationTableMapping = new TableMapping(publication, publicationTable, true); + publicationTable.AddTypeMapping(publicationTableMapping, false); + tableMappings5.Add(publicationTableMapping); + RelationalModel.CreateColumnMapping(idColumn5, publication.FindProperty("Id")!, publicationTableMapping); + RelationalModel.CreateColumnMapping(deletedAtColumn4, publication.FindProperty("DeletedAt")!, publicationTableMapping); + RelationalModel.CreateColumnMapping(nameColumn2, publication.FindProperty("Name")!, publicationTableMapping); + RelationalModel.CreateColumnMapping(snapshotIdColumn4, publication.FindProperty("SnapshotId")!, publicationTableMapping); + + var semanticDomain = FindEntityType("MiniLcm.Models.SemanticDomain")!; + + var defaultTableMappings6 = new List>(); + semanticDomain.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings6); + var miniLcmModelsSemanticDomainTableBase = new TableBase("MiniLcm.Models.SemanticDomain", null, relationalModel); + var codeColumnBase0 = new ColumnBase("Code", "TEXT", miniLcmModelsSemanticDomainTableBase); + miniLcmModelsSemanticDomainTableBase.Columns.Add("Code", codeColumnBase0); + var deletedAtColumnBase5 = new ColumnBase("DeletedAt", "TEXT", miniLcmModelsSemanticDomainTableBase) + { + IsNullable = true + }; + miniLcmModelsSemanticDomainTableBase.Columns.Add("DeletedAt", deletedAtColumnBase5); + var idColumnBase6 = new ColumnBase("Id", "TEXT", miniLcmModelsSemanticDomainTableBase); + miniLcmModelsSemanticDomainTableBase.Columns.Add("Id", idColumnBase6); + var nameColumnBase3 = new ColumnBase("Name", "jsonb", miniLcmModelsSemanticDomainTableBase); + miniLcmModelsSemanticDomainTableBase.Columns.Add("Name", nameColumnBase3); + var predefinedColumnBase0 = new ColumnBase("Predefined", "INTEGER", miniLcmModelsSemanticDomainTableBase); + miniLcmModelsSemanticDomainTableBase.Columns.Add("Predefined", predefinedColumnBase0); + var snapshotIdColumnBase5 = new ColumnBase("SnapshotId", "TEXT", miniLcmModelsSemanticDomainTableBase) + { + IsNullable = true + }; + miniLcmModelsSemanticDomainTableBase.Columns.Add("SnapshotId", snapshotIdColumnBase5); + relationalModel.DefaultTables.Add("MiniLcm.Models.SemanticDomain", miniLcmModelsSemanticDomainTableBase); + var miniLcmModelsSemanticDomainMappingBase = new TableMappingBase(semanticDomain, miniLcmModelsSemanticDomainTableBase, true); + miniLcmModelsSemanticDomainTableBase.AddTypeMapping(miniLcmModelsSemanticDomainMappingBase, false); + defaultTableMappings6.Add(miniLcmModelsSemanticDomainMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase6, semanticDomain.FindProperty("Id")!, miniLcmModelsSemanticDomainMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)codeColumnBase0, semanticDomain.FindProperty("Code")!, miniLcmModelsSemanticDomainMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)deletedAtColumnBase5, semanticDomain.FindProperty("DeletedAt")!, miniLcmModelsSemanticDomainMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)nameColumnBase3, semanticDomain.FindProperty("Name")!, miniLcmModelsSemanticDomainMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)predefinedColumnBase0, semanticDomain.FindProperty("Predefined")!, miniLcmModelsSemanticDomainMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)snapshotIdColumnBase5, semanticDomain.FindProperty("SnapshotId")!, miniLcmModelsSemanticDomainMappingBase); + + var tableMappings6 = new List(); + semanticDomain.SetRuntimeAnnotation("Relational:TableMappings", tableMappings6); + var semanticDomainTable = new Table("SemanticDomain", null, relationalModel); + var idColumn6 = new Column("Id", "TEXT", semanticDomainTable); + semanticDomainTable.Columns.Add("Id", idColumn6); + var codeColumn0 = new Column("Code", "TEXT", semanticDomainTable); + semanticDomainTable.Columns.Add("Code", codeColumn0); + var deletedAtColumn5 = new Column("DeletedAt", "TEXT", semanticDomainTable) + { + IsNullable = true + }; + semanticDomainTable.Columns.Add("DeletedAt", deletedAtColumn5); + var nameColumn3 = new Column("Name", "jsonb", semanticDomainTable); + semanticDomainTable.Columns.Add("Name", nameColumn3); + var predefinedColumn0 = new Column("Predefined", "INTEGER", semanticDomainTable); + semanticDomainTable.Columns.Add("Predefined", predefinedColumn0); + var snapshotIdColumn5 = new Column("SnapshotId", "TEXT", semanticDomainTable) + { + IsNullable = true + }; + semanticDomainTable.Columns.Add("SnapshotId", snapshotIdColumn5); + var pK_SemanticDomain = new UniqueConstraint("PK_SemanticDomain", semanticDomainTable, new[] { idColumn6 }); + semanticDomainTable.PrimaryKey = pK_SemanticDomain; + var pK_SemanticDomainUc = RelationalModel.GetKey(this, + "MiniLcm.Models.SemanticDomain", + new[] { "Id" }); + pK_SemanticDomain.MappedKeys.Add(pK_SemanticDomainUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_SemanticDomainUc).Add(pK_SemanticDomain); + semanticDomainTable.UniqueConstraints.Add("PK_SemanticDomain", pK_SemanticDomain); + var iX_SemanticDomain_SnapshotId = new TableIndex( + "IX_SemanticDomain_SnapshotId", semanticDomainTable, new[] { snapshotIdColumn5 }, true); + var iX_SemanticDomain_SnapshotIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.SemanticDomain", + new[] { "SnapshotId" }); + iX_SemanticDomain_SnapshotId.MappedIndexes.Add(iX_SemanticDomain_SnapshotIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_SemanticDomain_SnapshotIdIx).Add(iX_SemanticDomain_SnapshotId); + semanticDomainTable.Indexes.Add("IX_SemanticDomain_SnapshotId", iX_SemanticDomain_SnapshotId); + relationalModel.Tables.Add(("SemanticDomain", null), semanticDomainTable); + var semanticDomainTableMapping = new TableMapping(semanticDomain, semanticDomainTable, true); + semanticDomainTable.AddTypeMapping(semanticDomainTableMapping, false); + tableMappings6.Add(semanticDomainTableMapping); + RelationalModel.CreateColumnMapping(idColumn6, semanticDomain.FindProperty("Id")!, semanticDomainTableMapping); + RelationalModel.CreateColumnMapping(codeColumn0, semanticDomain.FindProperty("Code")!, semanticDomainTableMapping); + RelationalModel.CreateColumnMapping(deletedAtColumn5, semanticDomain.FindProperty("DeletedAt")!, semanticDomainTableMapping); + RelationalModel.CreateColumnMapping(nameColumn3, semanticDomain.FindProperty("Name")!, semanticDomainTableMapping); + RelationalModel.CreateColumnMapping(predefinedColumn0, semanticDomain.FindProperty("Predefined")!, semanticDomainTableMapping); + RelationalModel.CreateColumnMapping(snapshotIdColumn5, semanticDomain.FindProperty("SnapshotId")!, semanticDomainTableMapping); + + var sense = FindEntityType("MiniLcm.Models.Sense")!; + + var defaultTableMappings7 = new List>(); + sense.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings7); + var miniLcmModelsSenseTableBase = new TableBase("MiniLcm.Models.Sense", null, relationalModel); + var definitionColumnBase = new ColumnBase("Definition", "jsonb", miniLcmModelsSenseTableBase); + miniLcmModelsSenseTableBase.Columns.Add("Definition", definitionColumnBase); + var deletedAtColumnBase6 = new ColumnBase("DeletedAt", "TEXT", miniLcmModelsSenseTableBase) + { + IsNullable = true + }; + miniLcmModelsSenseTableBase.Columns.Add("DeletedAt", deletedAtColumnBase6); + var entryIdColumnBase = new ColumnBase("EntryId", "TEXT", miniLcmModelsSenseTableBase); + miniLcmModelsSenseTableBase.Columns.Add("EntryId", entryIdColumnBase); + var glossColumnBase = new ColumnBase("Gloss", "jsonb", miniLcmModelsSenseTableBase); + miniLcmModelsSenseTableBase.Columns.Add("Gloss", glossColumnBase); + var idColumnBase7 = new ColumnBase("Id", "TEXT", miniLcmModelsSenseTableBase); + miniLcmModelsSenseTableBase.Columns.Add("Id", idColumnBase7); + var orderColumnBase1 = new ColumnBase("Order", "REAL", miniLcmModelsSenseTableBase); + miniLcmModelsSenseTableBase.Columns.Add("Order", orderColumnBase1); + var partOfSpeechIdColumnBase = new ColumnBase("PartOfSpeechId", "TEXT", miniLcmModelsSenseTableBase) + { + IsNullable = true + }; + miniLcmModelsSenseTableBase.Columns.Add("PartOfSpeechId", partOfSpeechIdColumnBase); + var semanticDomainsColumnBase = new ColumnBase("SemanticDomains", "jsonb", miniLcmModelsSenseTableBase); + miniLcmModelsSenseTableBase.Columns.Add("SemanticDomains", semanticDomainsColumnBase); + var snapshotIdColumnBase6 = new ColumnBase("SnapshotId", "TEXT", miniLcmModelsSenseTableBase) + { + IsNullable = true + }; + miniLcmModelsSenseTableBase.Columns.Add("SnapshotId", snapshotIdColumnBase6); + relationalModel.DefaultTables.Add("MiniLcm.Models.Sense", miniLcmModelsSenseTableBase); + var miniLcmModelsSenseMappingBase = new TableMappingBase(sense, miniLcmModelsSenseTableBase, true); + miniLcmModelsSenseTableBase.AddTypeMapping(miniLcmModelsSenseMappingBase, false); + defaultTableMappings7.Add(miniLcmModelsSenseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase7, sense.FindProperty("Id")!, miniLcmModelsSenseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)definitionColumnBase, sense.FindProperty("Definition")!, miniLcmModelsSenseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)deletedAtColumnBase6, sense.FindProperty("DeletedAt")!, miniLcmModelsSenseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)entryIdColumnBase, sense.FindProperty("EntryId")!, miniLcmModelsSenseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)glossColumnBase, sense.FindProperty("Gloss")!, miniLcmModelsSenseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)orderColumnBase1, sense.FindProperty("Order")!, miniLcmModelsSenseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)partOfSpeechIdColumnBase, sense.FindProperty("PartOfSpeechId")!, miniLcmModelsSenseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)semanticDomainsColumnBase, sense.FindProperty("SemanticDomains")!, miniLcmModelsSenseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)snapshotIdColumnBase6, sense.FindProperty("SnapshotId")!, miniLcmModelsSenseMappingBase); + + var tableMappings7 = new List(); + sense.SetRuntimeAnnotation("Relational:TableMappings", tableMappings7); + var senseTable = new Table("Sense", null, relationalModel); + var idColumn7 = new Column("Id", "TEXT", senseTable); + senseTable.Columns.Add("Id", idColumn7); + var definitionColumn = new Column("Definition", "jsonb", senseTable); + senseTable.Columns.Add("Definition", definitionColumn); + var deletedAtColumn6 = new Column("DeletedAt", "TEXT", senseTable) + { + IsNullable = true + }; + senseTable.Columns.Add("DeletedAt", deletedAtColumn6); + var entryIdColumn = new Column("EntryId", "TEXT", senseTable); + senseTable.Columns.Add("EntryId", entryIdColumn); + var glossColumn = new Column("Gloss", "jsonb", senseTable); + senseTable.Columns.Add("Gloss", glossColumn); + var orderColumn1 = new Column("Order", "REAL", senseTable); + senseTable.Columns.Add("Order", orderColumn1); + var partOfSpeechIdColumn = new Column("PartOfSpeechId", "TEXT", senseTable) + { + IsNullable = true + }; + senseTable.Columns.Add("PartOfSpeechId", partOfSpeechIdColumn); + var semanticDomainsColumn = new Column("SemanticDomains", "jsonb", senseTable); + senseTable.Columns.Add("SemanticDomains", semanticDomainsColumn); + var snapshotIdColumn6 = new Column("SnapshotId", "TEXT", senseTable) + { + IsNullable = true + }; + senseTable.Columns.Add("SnapshotId", snapshotIdColumn6); + var pK_Sense = new UniqueConstraint("PK_Sense", senseTable, new[] { idColumn7 }); + senseTable.PrimaryKey = pK_Sense; + var pK_SenseUc = RelationalModel.GetKey(this, + "MiniLcm.Models.Sense", + new[] { "Id" }); + pK_Sense.MappedKeys.Add(pK_SenseUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_SenseUc).Add(pK_Sense); + senseTable.UniqueConstraints.Add("PK_Sense", pK_Sense); + var iX_Sense_EntryId = new TableIndex( + "IX_Sense_EntryId", senseTable, new[] { entryIdColumn }, false); + var iX_Sense_EntryIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.Sense", + new[] { "EntryId" }); + iX_Sense_EntryId.MappedIndexes.Add(iX_Sense_EntryIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_Sense_EntryIdIx).Add(iX_Sense_EntryId); + senseTable.Indexes.Add("IX_Sense_EntryId", iX_Sense_EntryId); + var iX_Sense_PartOfSpeechId = new TableIndex( + "IX_Sense_PartOfSpeechId", senseTable, new[] { partOfSpeechIdColumn }, false); + var iX_Sense_PartOfSpeechIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.Sense", + new[] { "PartOfSpeechId" }); + iX_Sense_PartOfSpeechId.MappedIndexes.Add(iX_Sense_PartOfSpeechIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_Sense_PartOfSpeechIdIx).Add(iX_Sense_PartOfSpeechId); + senseTable.Indexes.Add("IX_Sense_PartOfSpeechId", iX_Sense_PartOfSpeechId); + var iX_Sense_SnapshotId = new TableIndex( + "IX_Sense_SnapshotId", senseTable, new[] { snapshotIdColumn6 }, true); + var iX_Sense_SnapshotIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.Sense", + new[] { "SnapshotId" }); + iX_Sense_SnapshotId.MappedIndexes.Add(iX_Sense_SnapshotIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_Sense_SnapshotIdIx).Add(iX_Sense_SnapshotId); + senseTable.Indexes.Add("IX_Sense_SnapshotId", iX_Sense_SnapshotId); + relationalModel.Tables.Add(("Sense", null), senseTable); + var senseTableMapping = new TableMapping(sense, senseTable, true); + senseTable.AddTypeMapping(senseTableMapping, false); + tableMappings7.Add(senseTableMapping); + RelationalModel.CreateColumnMapping(idColumn7, sense.FindProperty("Id")!, senseTableMapping); + RelationalModel.CreateColumnMapping(definitionColumn, sense.FindProperty("Definition")!, senseTableMapping); + RelationalModel.CreateColumnMapping(deletedAtColumn6, sense.FindProperty("DeletedAt")!, senseTableMapping); + RelationalModel.CreateColumnMapping(entryIdColumn, sense.FindProperty("EntryId")!, senseTableMapping); + RelationalModel.CreateColumnMapping(glossColumn, sense.FindProperty("Gloss")!, senseTableMapping); + RelationalModel.CreateColumnMapping(orderColumn1, sense.FindProperty("Order")!, senseTableMapping); + RelationalModel.CreateColumnMapping(partOfSpeechIdColumn, sense.FindProperty("PartOfSpeechId")!, senseTableMapping); + RelationalModel.CreateColumnMapping(semanticDomainsColumn, sense.FindProperty("SemanticDomains")!, senseTableMapping); + RelationalModel.CreateColumnMapping(snapshotIdColumn6, sense.FindProperty("SnapshotId")!, senseTableMapping); + + var writingSystem = FindEntityType("MiniLcm.Models.WritingSystem")!; + + var defaultTableMappings8 = new List>(); + writingSystem.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings8); + var miniLcmModelsWritingSystemTableBase = new TableBase("MiniLcm.Models.WritingSystem", null, relationalModel); + var abbreviationColumnBase = new ColumnBase("Abbreviation", "TEXT", miniLcmModelsWritingSystemTableBase); + miniLcmModelsWritingSystemTableBase.Columns.Add("Abbreviation", abbreviationColumnBase); + var deletedAtColumnBase7 = new ColumnBase("DeletedAt", "TEXT", miniLcmModelsWritingSystemTableBase) + { + IsNullable = true + }; + miniLcmModelsWritingSystemTableBase.Columns.Add("DeletedAt", deletedAtColumnBase7); + var exemplarsColumnBase = new ColumnBase("Exemplars", "jsonb", miniLcmModelsWritingSystemTableBase); + miniLcmModelsWritingSystemTableBase.Columns.Add("Exemplars", exemplarsColumnBase); + var fontColumnBase = new ColumnBase("Font", "TEXT", miniLcmModelsWritingSystemTableBase); + miniLcmModelsWritingSystemTableBase.Columns.Add("Font", fontColumnBase); + var idColumnBase8 = new ColumnBase("Id", "TEXT", miniLcmModelsWritingSystemTableBase); + miniLcmModelsWritingSystemTableBase.Columns.Add("Id", idColumnBase8); + var nameColumnBase4 = new ColumnBase("Name", "TEXT", miniLcmModelsWritingSystemTableBase); + miniLcmModelsWritingSystemTableBase.Columns.Add("Name", nameColumnBase4); + var orderColumnBase2 = new ColumnBase("Order", "REAL", miniLcmModelsWritingSystemTableBase); + miniLcmModelsWritingSystemTableBase.Columns.Add("Order", orderColumnBase2); + var snapshotIdColumnBase7 = new ColumnBase("SnapshotId", "TEXT", miniLcmModelsWritingSystemTableBase) + { + IsNullable = true + }; + miniLcmModelsWritingSystemTableBase.Columns.Add("SnapshotId", snapshotIdColumnBase7); + var typeColumnBase = new ColumnBase("Type", "INTEGER", miniLcmModelsWritingSystemTableBase); + miniLcmModelsWritingSystemTableBase.Columns.Add("Type", typeColumnBase); + var wsIdColumnBase = new ColumnBase("WsId", "TEXT", miniLcmModelsWritingSystemTableBase); + miniLcmModelsWritingSystemTableBase.Columns.Add("WsId", wsIdColumnBase); + relationalModel.DefaultTables.Add("MiniLcm.Models.WritingSystem", miniLcmModelsWritingSystemTableBase); + var miniLcmModelsWritingSystemMappingBase = new TableMappingBase(writingSystem, miniLcmModelsWritingSystemTableBase, true); + miniLcmModelsWritingSystemTableBase.AddTypeMapping(miniLcmModelsWritingSystemMappingBase, false); + defaultTableMappings8.Add(miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase8, writingSystem.FindProperty("Id")!, miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)abbreviationColumnBase, writingSystem.FindProperty("Abbreviation")!, miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)deletedAtColumnBase7, writingSystem.FindProperty("DeletedAt")!, miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)exemplarsColumnBase, writingSystem.FindProperty("Exemplars")!, miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)fontColumnBase, writingSystem.FindProperty("Font")!, miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)nameColumnBase4, writingSystem.FindProperty("Name")!, miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)orderColumnBase2, writingSystem.FindProperty("Order")!, miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)snapshotIdColumnBase7, writingSystem.FindProperty("SnapshotId")!, miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)typeColumnBase, writingSystem.FindProperty("Type")!, miniLcmModelsWritingSystemMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)wsIdColumnBase, writingSystem.FindProperty("WsId")!, miniLcmModelsWritingSystemMappingBase); + + var tableMappings8 = new List(); + writingSystem.SetRuntimeAnnotation("Relational:TableMappings", tableMappings8); + var writingSystemTable = new Table("WritingSystem", null, relationalModel); + var idColumn8 = new Column("Id", "TEXT", writingSystemTable); + writingSystemTable.Columns.Add("Id", idColumn8); + var abbreviationColumn = new Column("Abbreviation", "TEXT", writingSystemTable); + writingSystemTable.Columns.Add("Abbreviation", abbreviationColumn); + var deletedAtColumn7 = new Column("DeletedAt", "TEXT", writingSystemTable) + { + IsNullable = true + }; + writingSystemTable.Columns.Add("DeletedAt", deletedAtColumn7); + var exemplarsColumn = new Column("Exemplars", "jsonb", writingSystemTable); + writingSystemTable.Columns.Add("Exemplars", exemplarsColumn); + var fontColumn = new Column("Font", "TEXT", writingSystemTable); + writingSystemTable.Columns.Add("Font", fontColumn); + var nameColumn4 = new Column("Name", "TEXT", writingSystemTable); + writingSystemTable.Columns.Add("Name", nameColumn4); + var orderColumn2 = new Column("Order", "REAL", writingSystemTable); + writingSystemTable.Columns.Add("Order", orderColumn2); + var snapshotIdColumn7 = new Column("SnapshotId", "TEXT", writingSystemTable) + { + IsNullable = true + }; + writingSystemTable.Columns.Add("SnapshotId", snapshotIdColumn7); + var typeColumn = new Column("Type", "INTEGER", writingSystemTable); + writingSystemTable.Columns.Add("Type", typeColumn); + var wsIdColumn = new Column("WsId", "TEXT", writingSystemTable); + writingSystemTable.Columns.Add("WsId", wsIdColumn); + var pK_WritingSystem = new UniqueConstraint("PK_WritingSystem", writingSystemTable, new[] { idColumn8 }); + writingSystemTable.PrimaryKey = pK_WritingSystem; + var pK_WritingSystemUc = RelationalModel.GetKey(this, + "MiniLcm.Models.WritingSystem", + new[] { "Id" }); + pK_WritingSystem.MappedKeys.Add(pK_WritingSystemUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_WritingSystemUc).Add(pK_WritingSystem); + writingSystemTable.UniqueConstraints.Add("PK_WritingSystem", pK_WritingSystem); + var iX_WritingSystem_SnapshotId = new TableIndex( + "IX_WritingSystem_SnapshotId", writingSystemTable, new[] { snapshotIdColumn7 }, true); + var iX_WritingSystem_SnapshotIdIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.WritingSystem", + new[] { "SnapshotId" }); + iX_WritingSystem_SnapshotId.MappedIndexes.Add(iX_WritingSystem_SnapshotIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_WritingSystem_SnapshotIdIx).Add(iX_WritingSystem_SnapshotId); + writingSystemTable.Indexes.Add("IX_WritingSystem_SnapshotId", iX_WritingSystem_SnapshotId); + var iX_WritingSystem_WsId_Type = new TableIndex( + "IX_WritingSystem_WsId_Type", writingSystemTable, new[] { wsIdColumn, typeColumn }, true); + var iX_WritingSystem_WsId_TypeIx = RelationalModel.GetIndex(this, + "MiniLcm.Models.WritingSystem", + new[] { "WsId", "Type" }); + iX_WritingSystem_WsId_Type.MappedIndexes.Add(iX_WritingSystem_WsId_TypeIx); + RelationalModel.GetOrCreateTableIndexes(iX_WritingSystem_WsId_TypeIx).Add(iX_WritingSystem_WsId_Type); + writingSystemTable.Indexes.Add("IX_WritingSystem_WsId_Type", iX_WritingSystem_WsId_Type); + relationalModel.Tables.Add(("WritingSystem", null), writingSystemTable); + var writingSystemTableMapping = new TableMapping(writingSystem, writingSystemTable, true); + writingSystemTable.AddTypeMapping(writingSystemTableMapping, false); + tableMappings8.Add(writingSystemTableMapping); + RelationalModel.CreateColumnMapping(idColumn8, writingSystem.FindProperty("Id")!, writingSystemTableMapping); + RelationalModel.CreateColumnMapping(abbreviationColumn, writingSystem.FindProperty("Abbreviation")!, writingSystemTableMapping); + RelationalModel.CreateColumnMapping(deletedAtColumn7, writingSystem.FindProperty("DeletedAt")!, writingSystemTableMapping); + RelationalModel.CreateColumnMapping(exemplarsColumn, writingSystem.FindProperty("Exemplars")!, writingSystemTableMapping); + RelationalModel.CreateColumnMapping(fontColumn, writingSystem.FindProperty("Font")!, writingSystemTableMapping); + RelationalModel.CreateColumnMapping(nameColumn4, writingSystem.FindProperty("Name")!, writingSystemTableMapping); + RelationalModel.CreateColumnMapping(orderColumn2, writingSystem.FindProperty("Order")!, writingSystemTableMapping); + RelationalModel.CreateColumnMapping(snapshotIdColumn7, writingSystem.FindProperty("SnapshotId")!, writingSystemTableMapping); + RelationalModel.CreateColumnMapping(typeColumn, writingSystem.FindProperty("Type")!, writingSystemTableMapping); + RelationalModel.CreateColumnMapping(wsIdColumn, writingSystem.FindProperty("WsId")!, writingSystemTableMapping); + + var commit = FindEntityType("SIL.Harmony.Commit")!; + + var defaultTableMappings9 = new List>(); + commit.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings9); + var sILHarmonyCommitTableBase = new TableBase("SIL.Harmony.Commit", null, relationalModel); + var clientIdColumnBase0 = new ColumnBase("ClientId", "TEXT", sILHarmonyCommitTableBase); + sILHarmonyCommitTableBase.Columns.Add("ClientId", clientIdColumnBase0); + var hashColumnBase = new ColumnBase("Hash", "TEXT", sILHarmonyCommitTableBase); + sILHarmonyCommitTableBase.Columns.Add("Hash", hashColumnBase); + var hybridDateTime_CounterColumnBase = new ColumnBase("HybridDateTime_Counter", "INTEGER", sILHarmonyCommitTableBase); + sILHarmonyCommitTableBase.Columns.Add("HybridDateTime_Counter", hybridDateTime_CounterColumnBase); + var hybridDateTime_DateTimeColumnBase = new ColumnBase("HybridDateTime_DateTime", "TEXT", sILHarmonyCommitTableBase); + sILHarmonyCommitTableBase.Columns.Add("HybridDateTime_DateTime", hybridDateTime_DateTimeColumnBase); + var idColumnBase9 = new ColumnBase("Id", "TEXT", sILHarmonyCommitTableBase); + sILHarmonyCommitTableBase.Columns.Add("Id", idColumnBase9); + var metadataColumnBase = new ColumnBase("Metadata", "jsonb", sILHarmonyCommitTableBase); + sILHarmonyCommitTableBase.Columns.Add("Metadata", metadataColumnBase); + var parentHashColumnBase = new ColumnBase("ParentHash", "TEXT", sILHarmonyCommitTableBase); + sILHarmonyCommitTableBase.Columns.Add("ParentHash", parentHashColumnBase); + relationalModel.DefaultTables.Add("SIL.Harmony.Commit", sILHarmonyCommitTableBase); + var sILHarmonyCommitMappingBase = new TableMappingBase(commit, sILHarmonyCommitTableBase, true); + sILHarmonyCommitTableBase.AddTypeMapping(sILHarmonyCommitMappingBase, false); + defaultTableMappings9.Add(sILHarmonyCommitMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase9, commit.FindProperty("Id")!, sILHarmonyCommitMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)clientIdColumnBase0, commit.FindProperty("ClientId")!, sILHarmonyCommitMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)hashColumnBase, commit.FindProperty("Hash")!, sILHarmonyCommitMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)metadataColumnBase, commit.FindProperty("Metadata")!, sILHarmonyCommitMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)parentHashColumnBase, commit.FindProperty("ParentHash")!, sILHarmonyCommitMappingBase); + + var tableMappings9 = new List(); + commit.SetRuntimeAnnotation("Relational:TableMappings", tableMappings9); + var commitsTable = new Table("Commits", null, relationalModel); + var idColumn9 = new Column("Id", "TEXT", commitsTable); + commitsTable.Columns.Add("Id", idColumn9); + var clientIdColumn0 = new Column("ClientId", "TEXT", commitsTable); + commitsTable.Columns.Add("ClientId", clientIdColumn0); + var counterColumn = new Column("Counter", "INTEGER", commitsTable); + commitsTable.Columns.Add("Counter", counterColumn); + var dateTimeColumn = new Column("DateTime", "TEXT", commitsTable); + commitsTable.Columns.Add("DateTime", dateTimeColumn); + var hashColumn = new Column("Hash", "TEXT", commitsTable); + commitsTable.Columns.Add("Hash", hashColumn); + var metadataColumn = new Column("Metadata", "jsonb", commitsTable); + commitsTable.Columns.Add("Metadata", metadataColumn); + var parentHashColumn = new Column("ParentHash", "TEXT", commitsTable); + commitsTable.Columns.Add("ParentHash", parentHashColumn); + var pK_Commits = new UniqueConstraint("PK_Commits", commitsTable, new[] { idColumn9 }); + commitsTable.PrimaryKey = pK_Commits; + var pK_CommitsUc = RelationalModel.GetKey(this, + "SIL.Harmony.Commit", + new[] { "Id" }); + pK_Commits.MappedKeys.Add(pK_CommitsUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_CommitsUc).Add(pK_Commits); + commitsTable.UniqueConstraints.Add("PK_Commits", pK_Commits); + relationalModel.Tables.Add(("Commits", null), commitsTable); + var commitsTableMapping = new TableMapping(commit, commitsTable, true); + commitsTable.AddTypeMapping(commitsTableMapping, false); + tableMappings9.Add(commitsTableMapping); + RelationalModel.CreateColumnMapping(idColumn9, commit.FindProperty("Id")!, commitsTableMapping); + RelationalModel.CreateColumnMapping(clientIdColumn0, commit.FindProperty("ClientId")!, commitsTableMapping); + RelationalModel.CreateColumnMapping(hashColumn, commit.FindProperty("Hash")!, commitsTableMapping); + RelationalModel.CreateColumnMapping(metadataColumn, commit.FindProperty("Metadata")!, commitsTableMapping); + RelationalModel.CreateColumnMapping(parentHashColumn, commit.FindProperty("ParentHash")!, commitsTableMapping); + + var hybridDateTime = commit.FindComplexProperty("HybridDateTime")!.ComplexType; + + var defaultTableMappings10 = new List>(); + hybridDateTime.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings10); + var sILHarmonyCommitMappingBase0 = new TableMappingBase(hybridDateTime, sILHarmonyCommitTableBase, false); + sILHarmonyCommitTableBase.AddTypeMapping(sILHarmonyCommitMappingBase0, false); + defaultTableMappings10.Add(sILHarmonyCommitMappingBase0); + RelationalModel.CreateColumnMapping((ColumnBase)hybridDateTime_CounterColumnBase, hybridDateTime.FindProperty("Counter")!, sILHarmonyCommitMappingBase0); + RelationalModel.CreateColumnMapping((ColumnBase)hybridDateTime_DateTimeColumnBase, hybridDateTime.FindProperty("DateTime")!, sILHarmonyCommitMappingBase0); + + var tableMappings10 = new List(); + hybridDateTime.SetRuntimeAnnotation("Relational:TableMappings", tableMappings10); + var commitsTableMapping0 = new TableMapping(hybridDateTime, commitsTable, true); + commitsTable.AddTypeMapping(commitsTableMapping0, false); + tableMappings10.Add(commitsTableMapping0); + RelationalModel.CreateColumnMapping(counterColumn, hybridDateTime.FindProperty("Counter")!, commitsTableMapping0); + RelationalModel.CreateColumnMapping(dateTimeColumn, hybridDateTime.FindProperty("DateTime")!, commitsTableMapping0); + + var changeEntity = FindEntityType("SIL.Harmony.Core.ChangeEntity")!; + + var defaultTableMappings11 = new List>(); + changeEntity.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings11); + var sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase = new TableBase("SIL.Harmony.Core.ChangeEntity", null, relationalModel); + var changeColumnBase = new ColumnBase("Change", "jsonb", sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase) + { + IsNullable = true + }; + sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase.Columns.Add("Change", changeColumnBase); + var commitIdColumnBase = new ColumnBase("CommitId", "TEXT", sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase); + sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase.Columns.Add("CommitId", commitIdColumnBase); + var entityIdColumnBase = new ColumnBase("EntityId", "TEXT", sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase); + sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase.Columns.Add("EntityId", entityIdColumnBase); + var indexColumnBase = new ColumnBase("Index", "INTEGER", sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase); + sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase.Columns.Add("Index", indexColumnBase); + relationalModel.DefaultTables.Add("SIL.Harmony.Core.ChangeEntity", sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase); + var sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeMappingBase = new TableMappingBase(changeEntity, sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase, true); + sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeTableBase.AddTypeMapping(sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeMappingBase, false); + defaultTableMappings11.Add(sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)commitIdColumnBase, changeEntity.FindProperty("CommitId")!, sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)indexColumnBase, changeEntity.FindProperty("Index")!, sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)changeColumnBase, changeEntity.FindProperty("Change")!, sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)entityIdColumnBase, changeEntity.FindProperty("EntityId")!, sILHarmonyCoreChangeEntitySILHarmonyChangesIChangeMappingBase); + + var tableMappings11 = new List(); + changeEntity.SetRuntimeAnnotation("Relational:TableMappings", tableMappings11); + var changeEntitiesTable = new Table("ChangeEntities", null, relationalModel); + var commitIdColumn = new Column("CommitId", "TEXT", changeEntitiesTable); + changeEntitiesTable.Columns.Add("CommitId", commitIdColumn); + var indexColumn = new Column("Index", "INTEGER", changeEntitiesTable); + changeEntitiesTable.Columns.Add("Index", indexColumn); + var changeColumn = new Column("Change", "jsonb", changeEntitiesTable) + { + IsNullable = true + }; + changeEntitiesTable.Columns.Add("Change", changeColumn); + var entityIdColumn = new Column("EntityId", "TEXT", changeEntitiesTable); + changeEntitiesTable.Columns.Add("EntityId", entityIdColumn); + var pK_ChangeEntities = new UniqueConstraint("PK_ChangeEntities", changeEntitiesTable, new[] { commitIdColumn, indexColumn }); + changeEntitiesTable.PrimaryKey = pK_ChangeEntities; + var pK_ChangeEntitiesUc = RelationalModel.GetKey(this, + "SIL.Harmony.Core.ChangeEntity", + new[] { "CommitId", "Index" }); + pK_ChangeEntities.MappedKeys.Add(pK_ChangeEntitiesUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_ChangeEntitiesUc).Add(pK_ChangeEntities); + changeEntitiesTable.UniqueConstraints.Add("PK_ChangeEntities", pK_ChangeEntities); + relationalModel.Tables.Add(("ChangeEntities", null), changeEntitiesTable); + var changeEntitiesTableMapping = new TableMapping(changeEntity, changeEntitiesTable, true); + changeEntitiesTable.AddTypeMapping(changeEntitiesTableMapping, false); + tableMappings11.Add(changeEntitiesTableMapping); + RelationalModel.CreateColumnMapping(commitIdColumn, changeEntity.FindProperty("CommitId")!, changeEntitiesTableMapping); + RelationalModel.CreateColumnMapping(indexColumn, changeEntity.FindProperty("Index")!, changeEntitiesTableMapping); + RelationalModel.CreateColumnMapping(changeColumn, changeEntity.FindProperty("Change")!, changeEntitiesTableMapping); + RelationalModel.CreateColumnMapping(entityIdColumn, changeEntity.FindProperty("EntityId")!, changeEntitiesTableMapping); + + var objectSnapshot = FindEntityType("SIL.Harmony.Db.ObjectSnapshot")!; + + var defaultTableMappings12 = new List>(); + objectSnapshot.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings12); + var sILHarmonyDbObjectSnapshotTableBase = new TableBase("SIL.Harmony.Db.ObjectSnapshot", null, relationalModel); + var commitIdColumnBase0 = new ColumnBase("CommitId", "TEXT", sILHarmonyDbObjectSnapshotTableBase); + sILHarmonyDbObjectSnapshotTableBase.Columns.Add("CommitId", commitIdColumnBase0); + var entityColumnBase = new ColumnBase("Entity", "jsonb", sILHarmonyDbObjectSnapshotTableBase); + sILHarmonyDbObjectSnapshotTableBase.Columns.Add("Entity", entityColumnBase); + var entityIdColumnBase0 = new ColumnBase("EntityId", "TEXT", sILHarmonyDbObjectSnapshotTableBase); + sILHarmonyDbObjectSnapshotTableBase.Columns.Add("EntityId", entityIdColumnBase0); + var entityIsDeletedColumnBase = new ColumnBase("EntityIsDeleted", "INTEGER", sILHarmonyDbObjectSnapshotTableBase); + sILHarmonyDbObjectSnapshotTableBase.Columns.Add("EntityIsDeleted", entityIsDeletedColumnBase); + var idColumnBase10 = new ColumnBase("Id", "TEXT", sILHarmonyDbObjectSnapshotTableBase); + sILHarmonyDbObjectSnapshotTableBase.Columns.Add("Id", idColumnBase10); + var isRootColumnBase = new ColumnBase("IsRoot", "INTEGER", sILHarmonyDbObjectSnapshotTableBase); + sILHarmonyDbObjectSnapshotTableBase.Columns.Add("IsRoot", isRootColumnBase); + var referencesColumnBase = new ColumnBase("References", "TEXT", sILHarmonyDbObjectSnapshotTableBase); + sILHarmonyDbObjectSnapshotTableBase.Columns.Add("References", referencesColumnBase); + var typeNameColumnBase = new ColumnBase("TypeName", "TEXT", sILHarmonyDbObjectSnapshotTableBase); + sILHarmonyDbObjectSnapshotTableBase.Columns.Add("TypeName", typeNameColumnBase); + relationalModel.DefaultTables.Add("SIL.Harmony.Db.ObjectSnapshot", sILHarmonyDbObjectSnapshotTableBase); + var sILHarmonyDbObjectSnapshotMappingBase = new TableMappingBase(objectSnapshot, sILHarmonyDbObjectSnapshotTableBase, true); + sILHarmonyDbObjectSnapshotTableBase.AddTypeMapping(sILHarmonyDbObjectSnapshotMappingBase, false); + defaultTableMappings12.Add(sILHarmonyDbObjectSnapshotMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase10, objectSnapshot.FindProperty("Id")!, sILHarmonyDbObjectSnapshotMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)commitIdColumnBase0, objectSnapshot.FindProperty("CommitId")!, sILHarmonyDbObjectSnapshotMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)entityColumnBase, objectSnapshot.FindProperty("Entity")!, sILHarmonyDbObjectSnapshotMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)entityIdColumnBase0, objectSnapshot.FindProperty("EntityId")!, sILHarmonyDbObjectSnapshotMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)entityIsDeletedColumnBase, objectSnapshot.FindProperty("EntityIsDeleted")!, sILHarmonyDbObjectSnapshotMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)isRootColumnBase, objectSnapshot.FindProperty("IsRoot")!, sILHarmonyDbObjectSnapshotMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)referencesColumnBase, objectSnapshot.FindProperty("References")!, sILHarmonyDbObjectSnapshotMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)typeNameColumnBase, objectSnapshot.FindProperty("TypeName")!, sILHarmonyDbObjectSnapshotMappingBase); + + var tableMappings12 = new List(); + objectSnapshot.SetRuntimeAnnotation("Relational:TableMappings", tableMappings12); + var snapshotsTable = new Table("Snapshots", null, relationalModel); + var idColumn10 = new Column("Id", "TEXT", snapshotsTable); + snapshotsTable.Columns.Add("Id", idColumn10); + var commitIdColumn0 = new Column("CommitId", "TEXT", snapshotsTable); + snapshotsTable.Columns.Add("CommitId", commitIdColumn0); + var entityColumn = new Column("Entity", "jsonb", snapshotsTable); + snapshotsTable.Columns.Add("Entity", entityColumn); + var entityIdColumn0 = new Column("EntityId", "TEXT", snapshotsTable); + snapshotsTable.Columns.Add("EntityId", entityIdColumn0); + var entityIsDeletedColumn = new Column("EntityIsDeleted", "INTEGER", snapshotsTable); + snapshotsTable.Columns.Add("EntityIsDeleted", entityIsDeletedColumn); + var isRootColumn = new Column("IsRoot", "INTEGER", snapshotsTable); + snapshotsTable.Columns.Add("IsRoot", isRootColumn); + var referencesColumn = new Column("References", "TEXT", snapshotsTable); + snapshotsTable.Columns.Add("References", referencesColumn); + var typeNameColumn = new Column("TypeName", "TEXT", snapshotsTable); + snapshotsTable.Columns.Add("TypeName", typeNameColumn); + var pK_Snapshots = new UniqueConstraint("PK_Snapshots", snapshotsTable, new[] { idColumn10 }); + snapshotsTable.PrimaryKey = pK_Snapshots; + var pK_SnapshotsUc = RelationalModel.GetKey(this, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + pK_Snapshots.MappedKeys.Add(pK_SnapshotsUc); + RelationalModel.GetOrCreateUniqueConstraints(pK_SnapshotsUc).Add(pK_Snapshots); + snapshotsTable.UniqueConstraints.Add("PK_Snapshots", pK_Snapshots); + var iX_Snapshots_CommitId_EntityId = new TableIndex( + "IX_Snapshots_CommitId_EntityId", snapshotsTable, new[] { commitIdColumn0, entityIdColumn0 }, true); + var iX_Snapshots_CommitId_EntityIdIx = RelationalModel.GetIndex(this, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "CommitId", "EntityId" }); + iX_Snapshots_CommitId_EntityId.MappedIndexes.Add(iX_Snapshots_CommitId_EntityIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_Snapshots_CommitId_EntityIdIx).Add(iX_Snapshots_CommitId_EntityId); + snapshotsTable.Indexes.Add("IX_Snapshots_CommitId_EntityId", iX_Snapshots_CommitId_EntityId); + var iX_Snapshots_EntityId = new TableIndex( + "IX_Snapshots_EntityId", snapshotsTable, new[] { entityIdColumn0 }, false); + var iX_Snapshots_EntityIdIx = RelationalModel.GetIndex(this, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "EntityId" }); + iX_Snapshots_EntityId.MappedIndexes.Add(iX_Snapshots_EntityIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_Snapshots_EntityIdIx).Add(iX_Snapshots_EntityId); + snapshotsTable.Indexes.Add("IX_Snapshots_EntityId", iX_Snapshots_EntityId); + relationalModel.Tables.Add(("Snapshots", null), snapshotsTable); + var snapshotsTableMapping = new TableMapping(objectSnapshot, snapshotsTable, true); + snapshotsTable.AddTypeMapping(snapshotsTableMapping, false); + tableMappings12.Add(snapshotsTableMapping); + RelationalModel.CreateColumnMapping(idColumn10, objectSnapshot.FindProperty("Id")!, snapshotsTableMapping); + RelationalModel.CreateColumnMapping(commitIdColumn0, objectSnapshot.FindProperty("CommitId")!, snapshotsTableMapping); + RelationalModel.CreateColumnMapping(entityColumn, objectSnapshot.FindProperty("Entity")!, snapshotsTableMapping); + RelationalModel.CreateColumnMapping(entityIdColumn0, objectSnapshot.FindProperty("EntityId")!, snapshotsTableMapping); + RelationalModel.CreateColumnMapping(entityIsDeletedColumn, objectSnapshot.FindProperty("EntityIsDeleted")!, snapshotsTableMapping); + RelationalModel.CreateColumnMapping(isRootColumn, objectSnapshot.FindProperty("IsRoot")!, snapshotsTableMapping); + RelationalModel.CreateColumnMapping(referencesColumn, objectSnapshot.FindProperty("References")!, snapshotsTableMapping); + RelationalModel.CreateColumnMapping(typeNameColumn, objectSnapshot.FindProperty("TypeName")!, snapshotsTableMapping); + var fK_ChangeEntities_Commits_CommitId = new ForeignKeyConstraint( + "FK_ChangeEntities_Commits_CommitId", changeEntitiesTable, commitsTable, + new[] { commitIdColumn }, + commitsTable.FindUniqueConstraint("PK_Commits")!, ReferentialAction.Cascade); + var fK_ChangeEntities_Commits_CommitIdFk = RelationalModel.GetForeignKey(this, + "SIL.Harmony.Core.ChangeEntity", + new[] { "CommitId" }, + "SIL.Harmony.Commit", + new[] { "Id" }); + fK_ChangeEntities_Commits_CommitId.MappedForeignKeys.Add(fK_ChangeEntities_Commits_CommitIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_ChangeEntities_Commits_CommitIdFk).Add(fK_ChangeEntities_Commits_CommitId); + changeEntitiesTable.ForeignKeyConstraints.Add(fK_ChangeEntities_Commits_CommitId); + commitsTable.ReferencingForeignKeyConstraints.Add(fK_ChangeEntities_Commits_CommitId); + var fK_ComplexFormComponents_Entry_ComplexFormEntryId = new ForeignKeyConstraint( + "FK_ComplexFormComponents_Entry_ComplexFormEntryId", complexFormComponentsTable, entryTable, + new[] { complexFormEntryIdColumn }, + entryTable.FindUniqueConstraint("PK_Entry")!, ReferentialAction.Cascade); + var fK_ComplexFormComponents_Entry_ComplexFormEntryIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "ComplexFormEntryId" }, + "MiniLcm.Models.Entry", + new[] { "Id" }); + fK_ComplexFormComponents_Entry_ComplexFormEntryId.MappedForeignKeys.Add(fK_ComplexFormComponents_Entry_ComplexFormEntryIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_ComplexFormComponents_Entry_ComplexFormEntryIdFk).Add(fK_ComplexFormComponents_Entry_ComplexFormEntryId); + complexFormComponentsTable.ForeignKeyConstraints.Add(fK_ComplexFormComponents_Entry_ComplexFormEntryId); + entryTable.ReferencingForeignKeyConstraints.Add(fK_ComplexFormComponents_Entry_ComplexFormEntryId); + var fK_ComplexFormComponents_Entry_ComponentEntryId = new ForeignKeyConstraint( + "FK_ComplexFormComponents_Entry_ComponentEntryId", complexFormComponentsTable, entryTable, + new[] { componentEntryIdColumn }, + entryTable.FindUniqueConstraint("PK_Entry")!, ReferentialAction.Cascade); + var fK_ComplexFormComponents_Entry_ComponentEntryIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "ComponentEntryId" }, + "MiniLcm.Models.Entry", + new[] { "Id" }); + fK_ComplexFormComponents_Entry_ComponentEntryId.MappedForeignKeys.Add(fK_ComplexFormComponents_Entry_ComponentEntryIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_ComplexFormComponents_Entry_ComponentEntryIdFk).Add(fK_ComplexFormComponents_Entry_ComponentEntryId); + complexFormComponentsTable.ForeignKeyConstraints.Add(fK_ComplexFormComponents_Entry_ComponentEntryId); + entryTable.ReferencingForeignKeyConstraints.Add(fK_ComplexFormComponents_Entry_ComponentEntryId); + var fK_ComplexFormComponents_Sense_ComponentSenseId = new ForeignKeyConstraint( + "FK_ComplexFormComponents_Sense_ComponentSenseId", complexFormComponentsTable, senseTable, + new[] { componentSenseIdColumn }, + senseTable.FindUniqueConstraint("PK_Sense")!, ReferentialAction.Cascade); + var fK_ComplexFormComponents_Sense_ComponentSenseIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "ComponentSenseId" }, + "MiniLcm.Models.Sense", + new[] { "Id" }); + fK_ComplexFormComponents_Sense_ComponentSenseId.MappedForeignKeys.Add(fK_ComplexFormComponents_Sense_ComponentSenseIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_ComplexFormComponents_Sense_ComponentSenseIdFk).Add(fK_ComplexFormComponents_Sense_ComponentSenseId); + complexFormComponentsTable.ForeignKeyConstraints.Add(fK_ComplexFormComponents_Sense_ComponentSenseId); + senseTable.ReferencingForeignKeyConstraints.Add(fK_ComplexFormComponents_Sense_ComponentSenseId); + var fK_ComplexFormComponents_Snapshots_SnapshotId = new ForeignKeyConstraint( + "FK_ComplexFormComponents_Snapshots_SnapshotId", complexFormComponentsTable, snapshotsTable, + new[] { snapshotIdColumn }, + snapshotsTable.FindUniqueConstraint("PK_Snapshots")!, ReferentialAction.SetNull); + var fK_ComplexFormComponents_Snapshots_SnapshotIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.ComplexFormComponent", + new[] { "SnapshotId" }, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + fK_ComplexFormComponents_Snapshots_SnapshotId.MappedForeignKeys.Add(fK_ComplexFormComponents_Snapshots_SnapshotIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_ComplexFormComponents_Snapshots_SnapshotIdFk).Add(fK_ComplexFormComponents_Snapshots_SnapshotId); + complexFormComponentsTable.ForeignKeyConstraints.Add(fK_ComplexFormComponents_Snapshots_SnapshotId); + snapshotsTable.ReferencingForeignKeyConstraints.Add(fK_ComplexFormComponents_Snapshots_SnapshotId); + var fK_ComplexFormType_Snapshots_SnapshotId = new ForeignKeyConstraint( + "FK_ComplexFormType_Snapshots_SnapshotId", complexFormTypeTable, snapshotsTable, + new[] { snapshotIdColumn0 }, + snapshotsTable.FindUniqueConstraint("PK_Snapshots")!, ReferentialAction.SetNull); + var fK_ComplexFormType_Snapshots_SnapshotIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.ComplexFormType", + new[] { "SnapshotId" }, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + fK_ComplexFormType_Snapshots_SnapshotId.MappedForeignKeys.Add(fK_ComplexFormType_Snapshots_SnapshotIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_ComplexFormType_Snapshots_SnapshotIdFk).Add(fK_ComplexFormType_Snapshots_SnapshotId); + complexFormTypeTable.ForeignKeyConstraints.Add(fK_ComplexFormType_Snapshots_SnapshotId); + snapshotsTable.ReferencingForeignKeyConstraints.Add(fK_ComplexFormType_Snapshots_SnapshotId); + var fK_Entry_Snapshots_SnapshotId = new ForeignKeyConstraint( + "FK_Entry_Snapshots_SnapshotId", entryTable, snapshotsTable, + new[] { snapshotIdColumn1 }, + snapshotsTable.FindUniqueConstraint("PK_Snapshots")!, ReferentialAction.SetNull); + var fK_Entry_Snapshots_SnapshotIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.Entry", + new[] { "SnapshotId" }, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + fK_Entry_Snapshots_SnapshotId.MappedForeignKeys.Add(fK_Entry_Snapshots_SnapshotIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_Entry_Snapshots_SnapshotIdFk).Add(fK_Entry_Snapshots_SnapshotId); + entryTable.ForeignKeyConstraints.Add(fK_Entry_Snapshots_SnapshotId); + snapshotsTable.ReferencingForeignKeyConstraints.Add(fK_Entry_Snapshots_SnapshotId); + var fK_ExampleSentence_Sense_SenseId = new ForeignKeyConstraint( + "FK_ExampleSentence_Sense_SenseId", exampleSentenceTable, senseTable, + new[] { senseIdColumn }, + senseTable.FindUniqueConstraint("PK_Sense")!, ReferentialAction.Cascade); + var fK_ExampleSentence_Sense_SenseIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.ExampleSentence", + new[] { "SenseId" }, + "MiniLcm.Models.Sense", + new[] { "Id" }); + fK_ExampleSentence_Sense_SenseId.MappedForeignKeys.Add(fK_ExampleSentence_Sense_SenseIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_ExampleSentence_Sense_SenseIdFk).Add(fK_ExampleSentence_Sense_SenseId); + exampleSentenceTable.ForeignKeyConstraints.Add(fK_ExampleSentence_Sense_SenseId); + senseTable.ReferencingForeignKeyConstraints.Add(fK_ExampleSentence_Sense_SenseId); + var fK_ExampleSentence_Snapshots_SnapshotId = new ForeignKeyConstraint( + "FK_ExampleSentence_Snapshots_SnapshotId", exampleSentenceTable, snapshotsTable, + new[] { snapshotIdColumn2 }, + snapshotsTable.FindUniqueConstraint("PK_Snapshots")!, ReferentialAction.SetNull); + var fK_ExampleSentence_Snapshots_SnapshotIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.ExampleSentence", + new[] { "SnapshotId" }, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + fK_ExampleSentence_Snapshots_SnapshotId.MappedForeignKeys.Add(fK_ExampleSentence_Snapshots_SnapshotIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_ExampleSentence_Snapshots_SnapshotIdFk).Add(fK_ExampleSentence_Snapshots_SnapshotId); + exampleSentenceTable.ForeignKeyConstraints.Add(fK_ExampleSentence_Snapshots_SnapshotId); + snapshotsTable.ReferencingForeignKeyConstraints.Add(fK_ExampleSentence_Snapshots_SnapshotId); + var fK_PartOfSpeech_Snapshots_SnapshotId = new ForeignKeyConstraint( + "FK_PartOfSpeech_Snapshots_SnapshotId", partOfSpeechTable, snapshotsTable, + new[] { snapshotIdColumn3 }, + snapshotsTable.FindUniqueConstraint("PK_Snapshots")!, ReferentialAction.SetNull); + var fK_PartOfSpeech_Snapshots_SnapshotIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.PartOfSpeech", + new[] { "SnapshotId" }, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + fK_PartOfSpeech_Snapshots_SnapshotId.MappedForeignKeys.Add(fK_PartOfSpeech_Snapshots_SnapshotIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_PartOfSpeech_Snapshots_SnapshotIdFk).Add(fK_PartOfSpeech_Snapshots_SnapshotId); + partOfSpeechTable.ForeignKeyConstraints.Add(fK_PartOfSpeech_Snapshots_SnapshotId); + snapshotsTable.ReferencingForeignKeyConstraints.Add(fK_PartOfSpeech_Snapshots_SnapshotId); + var fK_Publication_Snapshots_SnapshotId = new ForeignKeyConstraint( + "FK_Publication_Snapshots_SnapshotId", publicationTable, snapshotsTable, + new[] { snapshotIdColumn4 }, + snapshotsTable.FindUniqueConstraint("PK_Snapshots")!, ReferentialAction.SetNull); + var fK_Publication_Snapshots_SnapshotIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.Publication", + new[] { "SnapshotId" }, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + fK_Publication_Snapshots_SnapshotId.MappedForeignKeys.Add(fK_Publication_Snapshots_SnapshotIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_Publication_Snapshots_SnapshotIdFk).Add(fK_Publication_Snapshots_SnapshotId); + publicationTable.ForeignKeyConstraints.Add(fK_Publication_Snapshots_SnapshotId); + snapshotsTable.ReferencingForeignKeyConstraints.Add(fK_Publication_Snapshots_SnapshotId); + var fK_SemanticDomain_Snapshots_SnapshotId = new ForeignKeyConstraint( + "FK_SemanticDomain_Snapshots_SnapshotId", semanticDomainTable, snapshotsTable, + new[] { snapshotIdColumn5 }, + snapshotsTable.FindUniqueConstraint("PK_Snapshots")!, ReferentialAction.SetNull); + var fK_SemanticDomain_Snapshots_SnapshotIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.SemanticDomain", + new[] { "SnapshotId" }, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + fK_SemanticDomain_Snapshots_SnapshotId.MappedForeignKeys.Add(fK_SemanticDomain_Snapshots_SnapshotIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_SemanticDomain_Snapshots_SnapshotIdFk).Add(fK_SemanticDomain_Snapshots_SnapshotId); + semanticDomainTable.ForeignKeyConstraints.Add(fK_SemanticDomain_Snapshots_SnapshotId); + snapshotsTable.ReferencingForeignKeyConstraints.Add(fK_SemanticDomain_Snapshots_SnapshotId); + var fK_Sense_Entry_EntryId = new ForeignKeyConstraint( + "FK_Sense_Entry_EntryId", senseTable, entryTable, + new[] { entryIdColumn }, + entryTable.FindUniqueConstraint("PK_Entry")!, ReferentialAction.Cascade); + var fK_Sense_Entry_EntryIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.Sense", + new[] { "EntryId" }, + "MiniLcm.Models.Entry", + new[] { "Id" }); + fK_Sense_Entry_EntryId.MappedForeignKeys.Add(fK_Sense_Entry_EntryIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_Sense_Entry_EntryIdFk).Add(fK_Sense_Entry_EntryId); + senseTable.ForeignKeyConstraints.Add(fK_Sense_Entry_EntryId); + entryTable.ReferencingForeignKeyConstraints.Add(fK_Sense_Entry_EntryId); + var fK_Sense_PartOfSpeech_PartOfSpeechId = new ForeignKeyConstraint( + "FK_Sense_PartOfSpeech_PartOfSpeechId", senseTable, partOfSpeechTable, + new[] { partOfSpeechIdColumn }, + partOfSpeechTable.FindUniqueConstraint("PK_PartOfSpeech")!, ReferentialAction.NoAction); + var fK_Sense_PartOfSpeech_PartOfSpeechIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.Sense", + new[] { "PartOfSpeechId" }, + "MiniLcm.Models.PartOfSpeech", + new[] { "Id" }); + fK_Sense_PartOfSpeech_PartOfSpeechId.MappedForeignKeys.Add(fK_Sense_PartOfSpeech_PartOfSpeechIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_Sense_PartOfSpeech_PartOfSpeechIdFk).Add(fK_Sense_PartOfSpeech_PartOfSpeechId); + senseTable.ForeignKeyConstraints.Add(fK_Sense_PartOfSpeech_PartOfSpeechId); + partOfSpeechTable.ReferencingForeignKeyConstraints.Add(fK_Sense_PartOfSpeech_PartOfSpeechId); + var fK_Sense_Snapshots_SnapshotId = new ForeignKeyConstraint( + "FK_Sense_Snapshots_SnapshotId", senseTable, snapshotsTable, + new[] { snapshotIdColumn6 }, + snapshotsTable.FindUniqueConstraint("PK_Snapshots")!, ReferentialAction.SetNull); + var fK_Sense_Snapshots_SnapshotIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.Sense", + new[] { "SnapshotId" }, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + fK_Sense_Snapshots_SnapshotId.MappedForeignKeys.Add(fK_Sense_Snapshots_SnapshotIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_Sense_Snapshots_SnapshotIdFk).Add(fK_Sense_Snapshots_SnapshotId); + senseTable.ForeignKeyConstraints.Add(fK_Sense_Snapshots_SnapshotId); + snapshotsTable.ReferencingForeignKeyConstraints.Add(fK_Sense_Snapshots_SnapshotId); + var fK_Snapshots_Commits_CommitId = new ForeignKeyConstraint( + "FK_Snapshots_Commits_CommitId", snapshotsTable, commitsTable, + new[] { commitIdColumn0 }, + commitsTable.FindUniqueConstraint("PK_Commits")!, ReferentialAction.Cascade); + var fK_Snapshots_Commits_CommitIdFk = RelationalModel.GetForeignKey(this, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "CommitId" }, + "SIL.Harmony.Commit", + new[] { "Id" }); + fK_Snapshots_Commits_CommitId.MappedForeignKeys.Add(fK_Snapshots_Commits_CommitIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_Snapshots_Commits_CommitIdFk).Add(fK_Snapshots_Commits_CommitId); + snapshotsTable.ForeignKeyConstraints.Add(fK_Snapshots_Commits_CommitId); + commitsTable.ReferencingForeignKeyConstraints.Add(fK_Snapshots_Commits_CommitId); + var fK_WritingSystem_Snapshots_SnapshotId = new ForeignKeyConstraint( + "FK_WritingSystem_Snapshots_SnapshotId", writingSystemTable, snapshotsTable, + new[] { snapshotIdColumn7 }, + snapshotsTable.FindUniqueConstraint("PK_Snapshots")!, ReferentialAction.SetNull); + var fK_WritingSystem_Snapshots_SnapshotIdFk = RelationalModel.GetForeignKey(this, + "MiniLcm.Models.WritingSystem", + new[] { "SnapshotId" }, + "SIL.Harmony.Db.ObjectSnapshot", + new[] { "Id" }); + fK_WritingSystem_Snapshots_SnapshotId.MappedForeignKeys.Add(fK_WritingSystem_Snapshots_SnapshotIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_WritingSystem_Snapshots_SnapshotIdFk).Add(fK_WritingSystem_Snapshots_SnapshotId); + writingSystemTable.ForeignKeyConstraints.Add(fK_WritingSystem_Snapshots_SnapshotId); + snapshotsTable.ReferencingForeignKeyConstraints.Add(fK_WritingSystem_Snapshots_SnapshotId); + return relationalModel.MakeReadOnly(); + } + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/ObjectSnapshotEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/ObjectSnapshotEntityType.cs new file mode 100644 index 0000000000..1456d5e633 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/ObjectSnapshotEntityType.cs @@ -0,0 +1,216 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Json.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using SIL.Harmony; +using SIL.Harmony.Core; +using SIL.Harmony.Db; +using SIL.Harmony.Db.EntityConfig; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class ObjectSnapshotEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "SIL.Harmony.Db.ObjectSnapshot", + typeof(ObjectSnapshot), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(ObjectSnapshot).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ObjectSnapshot).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var commitId = runtimeEntityType.AddProperty( + "CommitId", + typeof(Guid), + propertyInfo: typeof(ObjectSnapshot).GetProperty("CommitId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ObjectSnapshot).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + commitId.TypeMapping = SqliteGuidTypeMapping.Default; + + var entity = runtimeEntityType.AddProperty( + "Entity", + typeof(IObjectBase), + propertyInfo: typeof(ObjectSnapshot).GetProperty("Entity", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ObjectSnapshot).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + entity.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (IObjectBase v1, IObjectBase v2) => object.Equals(v1, v2), + (IObjectBase v) => v.GetHashCode(), + (IObjectBase v) => v), + keyComparer: new ValueComparer( + (IObjectBase v1, IObjectBase v2) => object.Equals(v1, v2), + (IObjectBase v) => v.GetHashCode(), + (IObjectBase v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (IObjectBase entry) => SnapshotEntityConfig.Serialize(entry, null), + (string json) => SnapshotEntityConfig.DeserializeObject(json, null)), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (IObjectBase entry) => SnapshotEntityConfig.Serialize(entry, null), + (string json) => SnapshotEntityConfig.DeserializeObject(json, null)))); + entity.AddAnnotation("Relational:ColumnType", "jsonb"); + + var entityId = runtimeEntityType.AddProperty( + "EntityId", + typeof(Guid), + propertyInfo: typeof(ObjectSnapshot).GetProperty("EntityId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ObjectSnapshot).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + entityId.TypeMapping = SqliteGuidTypeMapping.Default; + + var entityIsDeleted = runtimeEntityType.AddProperty( + "EntityIsDeleted", + typeof(bool), + propertyInfo: typeof(ObjectSnapshot).GetProperty("EntityIsDeleted", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ObjectSnapshot).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: false); + entityIsDeleted.TypeMapping = BoolTypeMapping.Default.Clone( + comparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + keyComparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + providerValueComparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "INTEGER")); + + var isRoot = runtimeEntityType.AddProperty( + "IsRoot", + typeof(bool), + propertyInfo: typeof(ObjectSnapshot).GetProperty("IsRoot", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ObjectSnapshot).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: false); + isRoot.TypeMapping = BoolTypeMapping.Default.Clone( + comparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + keyComparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + providerValueComparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "INTEGER")); + + var references = runtimeEntityType.AddProperty( + "References", + typeof(Guid[]), + propertyInfo: typeof(ObjectSnapshot).GetProperty("References", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ObjectSnapshot).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + references.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ListComparer(new ValueComparer( + (Guid v1, Guid v2) => v1 == v2, + (Guid v) => v.GetHashCode(), + (Guid v) => v)), + keyComparer: new ListComparer(new ValueComparer( + (Guid v1, Guid v2) => v1 == v2, + (Guid v) => v.GetHashCode(), + (Guid v) => v)), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + SqliteJsonGuidReaderWriter.Instance)), + jsonValueReaderWriter: new JsonCollectionReaderWriter( + SqliteJsonGuidReaderWriter.Instance), + elementMapping: SqliteGuidTypeMapping.Default); + + var typeName = runtimeEntityType.AddProperty( + "TypeName", + typeof(string), + propertyInfo: typeof(ObjectSnapshot).GetProperty("TypeName", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ObjectSnapshot).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + typeName.TypeMapping = SqliteStringTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { entityId }); + + var index0 = runtimeEntityType.AddIndex( + new[] { commitId, entityId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("CommitId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + required: true); + + var commit = declaringEntityType.AddNavigation("Commit", + runtimeForeignKey, + onDependent: true, + typeof(Commit), + propertyInfo: typeof(ObjectSnapshot).GetProperty("Commit", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ObjectSnapshot).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + var snapshots = principalEntityType.AddNavigation("Snapshots", + runtimeForeignKey, + onDependent: false, + typeof(List), + propertyInfo: typeof(Commit).GetProperty("Snapshots", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Commit).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "Snapshots"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/PartOfSpeechEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/PartOfSpeechEntityType.cs new file mode 100644 index 0000000000..b65d4bcf76 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/PartOfSpeechEntityType.cs @@ -0,0 +1,140 @@ +// +using System; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using MiniLcm.Models; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class PartOfSpeechEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "MiniLcm.Models.PartOfSpeech", + typeof(PartOfSpeech), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(PartOfSpeech).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(PartOfSpeech).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var deletedAt = runtimeEntityType.AddProperty( + "DeletedAt", + typeof(DateTimeOffset?), + propertyInfo: typeof(PartOfSpeech).GetProperty("DeletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(PartOfSpeech).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + deletedAt.TypeMapping = SqliteDateTimeOffsetTypeMapping.Default; + + var name = runtimeEntityType.AddProperty( + "Name", + typeof(MultiString), + propertyInfo: typeof(PartOfSpeech).GetProperty("Name", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(PartOfSpeech).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.MultiStringDbConverter()); + name.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + keyComparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()))); + name.AddAnnotation("Relational:ColumnType", "jsonb"); + + var predefined = runtimeEntityType.AddProperty( + "Predefined", + typeof(bool), + propertyInfo: typeof(PartOfSpeech).GetProperty("Predefined", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(PartOfSpeech).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: false); + predefined.TypeMapping = BoolTypeMapping.Default.Clone( + comparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + keyComparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + providerValueComparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "INTEGER")); + + var snapshotId = runtimeEntityType.AddProperty( + "SnapshotId", + typeof(Guid?), + nullable: true); + snapshotId.TypeMapping = SqliteGuidTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { snapshotId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SnapshotId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.SetNull, + unique: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "PartOfSpeech"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/ProjectDataEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/ProjectDataEntityType.cs new file mode 100644 index 0000000000..35f3e313b5 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/ProjectDataEntityType.cs @@ -0,0 +1,106 @@ +// +using System; +using System.Reflection; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class ProjectDataEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "LcmCrdt.ProjectData", + typeof(ProjectData), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(ProjectData).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ProjectData).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var clientId = runtimeEntityType.AddProperty( + "ClientId", + typeof(Guid), + propertyInfo: typeof(ProjectData).GetProperty("ClientId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ProjectData).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + clientId.TypeMapping = SqliteGuidTypeMapping.Default; + + var code = runtimeEntityType.AddProperty( + "Code", + typeof(string), + propertyInfo: typeof(ProjectData).GetProperty("Code", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ProjectData).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + code.TypeMapping = SqliteStringTypeMapping.Default; + + var fwProjectId = runtimeEntityType.AddProperty( + "FwProjectId", + typeof(Guid?), + propertyInfo: typeof(ProjectData).GetProperty("FwProjectId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ProjectData).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + fwProjectId.TypeMapping = SqliteGuidTypeMapping.Default; + + var lastUserId = runtimeEntityType.AddProperty( + "LastUserId", + typeof(string), + propertyInfo: typeof(ProjectData).GetProperty("LastUserId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ProjectData).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + lastUserId.TypeMapping = SqliteStringTypeMapping.Default; + + var lastUserName = runtimeEntityType.AddProperty( + "LastUserName", + typeof(string), + propertyInfo: typeof(ProjectData).GetProperty("LastUserName", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ProjectData).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + lastUserName.TypeMapping = SqliteStringTypeMapping.Default; + + var name = runtimeEntityType.AddProperty( + "Name", + typeof(string), + propertyInfo: typeof(ProjectData).GetProperty("Name", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ProjectData).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + name.TypeMapping = SqliteStringTypeMapping.Default; + + var originDomain = runtimeEntityType.AddProperty( + "OriginDomain", + typeof(string), + propertyInfo: typeof(ProjectData).GetProperty("OriginDomain", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(ProjectData).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + originDomain.TypeMapping = SqliteStringTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + return runtimeEntityType; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "ProjectData"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/PublicationEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/PublicationEntityType.cs new file mode 100644 index 0000000000..dc4b6f390b --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/PublicationEntityType.cs @@ -0,0 +1,118 @@ +// +using System; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using MiniLcm.Models; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class PublicationEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "MiniLcm.Models.Publication", + typeof(Publication), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(Publication).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Publication).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var deletedAt = runtimeEntityType.AddProperty( + "DeletedAt", + typeof(DateTimeOffset?), + propertyInfo: typeof(Publication).GetProperty("DeletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Publication).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + deletedAt.TypeMapping = SqliteDateTimeOffsetTypeMapping.Default; + + var name = runtimeEntityType.AddProperty( + "Name", + typeof(MultiString), + propertyInfo: typeof(Publication).GetProperty("Name", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Publication).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.MultiStringDbConverter()); + name.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + keyComparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()))); + name.AddAnnotation("Relational:ColumnType", "jsonb"); + + var snapshotId = runtimeEntityType.AddProperty( + "SnapshotId", + typeof(Guid?), + nullable: true); + snapshotId.TypeMapping = SqliteGuidTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { snapshotId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SnapshotId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.SetNull, + unique: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "Publication"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/SemanticDomainEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/SemanticDomainEntityType.cs new file mode 100644 index 0000000000..203b204a91 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/SemanticDomainEntityType.cs @@ -0,0 +1,147 @@ +// +using System; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using MiniLcm.Models; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class SemanticDomainEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "MiniLcm.Models.SemanticDomain", + typeof(SemanticDomain), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(SemanticDomain).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(SemanticDomain).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var code = runtimeEntityType.AddProperty( + "Code", + typeof(string), + propertyInfo: typeof(SemanticDomain).GetProperty("Code", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(SemanticDomain).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + code.TypeMapping = SqliteStringTypeMapping.Default; + + var deletedAt = runtimeEntityType.AddProperty( + "DeletedAt", + typeof(DateTimeOffset?), + propertyInfo: typeof(SemanticDomain).GetProperty("DeletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(SemanticDomain).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + deletedAt.TypeMapping = SqliteDateTimeOffsetTypeMapping.Default; + + var name = runtimeEntityType.AddProperty( + "Name", + typeof(MultiString), + propertyInfo: typeof(SemanticDomain).GetProperty("Name", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(SemanticDomain).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.MultiStringDbConverter()); + name.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + keyComparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()))); + name.AddAnnotation("Relational:ColumnType", "jsonb"); + + var predefined = runtimeEntityType.AddProperty( + "Predefined", + typeof(bool), + propertyInfo: typeof(SemanticDomain).GetProperty("Predefined", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(SemanticDomain).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: false); + predefined.TypeMapping = BoolTypeMapping.Default.Clone( + comparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + keyComparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + providerValueComparer: new ValueComparer( + (bool v1, bool v2) => v1 == v2, + (bool v) => v.GetHashCode(), + (bool v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "INTEGER")); + + var snapshotId = runtimeEntityType.AddProperty( + "SnapshotId", + typeof(Guid?), + nullable: true); + snapshotId.TypeMapping = SqliteGuidTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { snapshotId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SnapshotId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.SetNull, + unique: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "SemanticDomain"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/SenseEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/SenseEntityType.cs new file mode 100644 index 0000000000..66e3f7948c --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/SenseEntityType.cs @@ -0,0 +1,258 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using MiniLcm.Models; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class SenseEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "MiniLcm.Models.Sense", + typeof(Sense), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(Sense).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var definition = runtimeEntityType.AddProperty( + "Definition", + typeof(RichMultiString), + propertyInfo: typeof(Sense).GetProperty("Definition", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.RichMultiStringDbConverter()); + definition.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + keyComparer: new ValueComparer( + (RichMultiString v1, RichMultiString v2) => object.Equals(v1, v2), + (RichMultiString v) => v.GetHashCode(), + (RichMultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (RichMultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new RichMultiString()))); + definition.AddAnnotation("Relational:ColumnType", "jsonb"); + + var deletedAt = runtimeEntityType.AddProperty( + "DeletedAt", + typeof(DateTimeOffset?), + propertyInfo: typeof(Sense).GetProperty("DeletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + deletedAt.TypeMapping = SqliteDateTimeOffsetTypeMapping.Default; + + var entryId = runtimeEntityType.AddProperty( + "EntryId", + typeof(Guid), + propertyInfo: typeof(Sense).GetProperty("EntryId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + entryId.TypeMapping = SqliteGuidTypeMapping.Default; + + var gloss = runtimeEntityType.AddProperty( + "Gloss", + typeof(MultiString), + propertyInfo: typeof(Sense).GetProperty("Gloss", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.MultiStringDbConverter()); + gloss.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + keyComparer: new ValueComparer( + (MultiString v1, MultiString v2) => object.Equals(v1, v2), + (MultiString v) => v.GetHashCode(), + (MultiString v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (MultiString mul) => LcmCrdtDbContext.Serialize(mul), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? new MultiString()))); + gloss.AddAnnotation("Relational:ColumnType", "jsonb"); + + var order = runtimeEntityType.AddProperty( + "Order", + typeof(double), + propertyInfo: typeof(Sense).GetProperty("Order", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0.0); + order.TypeMapping = DoubleTypeMapping.Default.Clone( + comparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + keyComparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + providerValueComparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "REAL")); + + var partOfSpeechId = runtimeEntityType.AddProperty( + "PartOfSpeechId", + typeof(Guid?), + propertyInfo: typeof(Sense).GetProperty("PartOfSpeechId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + partOfSpeechId.TypeMapping = SqliteGuidTypeMapping.Default; + + var semanticDomains = runtimeEntityType.AddProperty( + "SemanticDomains", + typeof(IList), + propertyInfo: typeof(Sense).GetProperty("SemanticDomains", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + semanticDomains.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer>( + (IList v1, IList v2) => object.Equals(v1, v2), + (IList v) => v.GetHashCode(), + (IList v) => v), + keyComparer: new ValueComparer>( + (IList v1, IList v2) => object.Equals(v1, v2), + (IList v) => v.GetHashCode(), + (IList v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter, string>( + (IList list) => LcmCrdtDbContext.Serialize(list), + (string json) => LcmCrdtDbContext.Deserialize>(json) ?? new List()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter, string>( + JsonStringReaderWriter.Instance, + new ValueConverter, string>( + (IList list) => LcmCrdtDbContext.Serialize(list), + (string json) => LcmCrdtDbContext.Deserialize>(json) ?? new List()))); + semanticDomains.AddAnnotation("Relational:ColumnType", "jsonb"); + + var snapshotId = runtimeEntityType.AddProperty( + "SnapshotId", + typeof(Guid?), + nullable: true); + snapshotId.TypeMapping = SqliteGuidTypeMapping.Default; + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { entryId }); + + var index0 = runtimeEntityType.AddIndex( + new[] { partOfSpeechId }); + + var index1 = runtimeEntityType.AddIndex( + new[] { snapshotId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("EntryId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + required: true); + + var senses = principalEntityType.AddNavigation("Senses", + runtimeForeignKey, + onDependent: false, + typeof(List), + propertyInfo: typeof(Entry).GetProperty("Senses", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Entry).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PartOfSpeechId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType); + + var partOfSpeech = declaringEntityType.AddNavigation("PartOfSpeech", + runtimeForeignKey, + onDependent: true, + typeof(PartOfSpeech), + propertyInfo: typeof(Sense).GetProperty("PartOfSpeech", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(Sense).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey3(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SnapshotId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.SetNull, + unique: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "Sense"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/CompiledModels/WritingSystemEntityType.cs b/backend/FwLite/LcmCrdt/CompiledModels/WritingSystemEntityType.cs new file mode 100644 index 0000000000..3a5bc8a293 --- /dev/null +++ b/backend/FwLite/LcmCrdt/CompiledModels/WritingSystemEntityType.cs @@ -0,0 +1,225 @@ +// +using System; +using System.Collections; +using System.Linq; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Sqlite.Storage.Internal; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using MiniLcm.Models; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace LcmCrdt.CompiledModels +{ + internal partial class WritingSystemEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "MiniLcm.Models.WritingSystem", + typeof(WritingSystem), + baseEntityType); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(Guid), + propertyInfo: typeof(WritingSystem).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(WritingSystem).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + id.TypeMapping = SqliteGuidTypeMapping.Default; + + var abbreviation = runtimeEntityType.AddProperty( + "Abbreviation", + typeof(string), + propertyInfo: typeof(WritingSystem).GetProperty("Abbreviation", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(WritingSystem).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + abbreviation.TypeMapping = SqliteStringTypeMapping.Default; + + var deletedAt = runtimeEntityType.AddProperty( + "DeletedAt", + typeof(DateTimeOffset?), + propertyInfo: typeof(WritingSystem).GetProperty("DeletedAt", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(WritingSystem).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + deletedAt.TypeMapping = SqliteDateTimeOffsetTypeMapping.Default; + + var exemplars = runtimeEntityType.AddProperty( + "Exemplars", + typeof(string[]), + propertyInfo: typeof(WritingSystem).GetProperty("Exemplars", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(WritingSystem).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + exemplars.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (String[] v1, String[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), + (String[] v) => v.GetHashCode(), + (String[] v) => v), + keyComparer: new ValueComparer( + (String[] v1, String[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), + (String[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), + (String[] source) => source.ToArray()), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "jsonb"), + converter: new ValueConverter( + (String[] list) => LcmCrdtDbContext.Serialize(list), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? Array.Empty()), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (String[] list) => LcmCrdtDbContext.Serialize(list), + (string json) => LcmCrdtDbContext.Deserialize(json) ?? Array.Empty()))); + exemplars.AddAnnotation("Relational:ColumnType", "jsonb"); + + var font = runtimeEntityType.AddProperty( + "Font", + typeof(string), + propertyInfo: typeof(WritingSystem).GetProperty("Font", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(WritingSystem).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + font.TypeMapping = SqliteStringTypeMapping.Default; + + var name = runtimeEntityType.AddProperty( + "Name", + typeof(string), + propertyInfo: typeof(WritingSystem).GetProperty("Name", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(WritingSystem).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + name.TypeMapping = SqliteStringTypeMapping.Default; + + var order = runtimeEntityType.AddProperty( + "Order", + typeof(double), + propertyInfo: typeof(WritingSystem).GetProperty("Order", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(WritingSystem).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0.0); + order.TypeMapping = DoubleTypeMapping.Default.Clone( + comparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + keyComparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + providerValueComparer: new ValueComparer( + (double v1, double v2) => v1.Equals(v2), + (double v) => v.GetHashCode(), + (double v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "REAL")); + + var snapshotId = runtimeEntityType.AddProperty( + "SnapshotId", + typeof(Guid?), + nullable: true); + snapshotId.TypeMapping = SqliteGuidTypeMapping.Default; + + var type = runtimeEntityType.AddProperty( + "Type", + typeof(WritingSystemType), + propertyInfo: typeof(WritingSystem).GetProperty("Type", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(WritingSystem).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + type.TypeMapping = IntTypeMapping.Default.Clone( + comparer: new ValueComparer( + (WritingSystemType v1, WritingSystemType v2) => object.Equals((object)v1, (object)v2), + (WritingSystemType v) => v.GetHashCode(), + (WritingSystemType v) => v), + keyComparer: new ValueComparer( + (WritingSystemType v1, WritingSystemType v2) => object.Equals((object)v1, (object)v2), + (WritingSystemType v) => v.GetHashCode(), + (WritingSystemType v) => v), + providerValueComparer: new ValueComparer( + (int v1, int v2) => v1 == v2, + (int v) => v, + (int v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "INTEGER"), + converter: new ValueConverter( + (WritingSystemType value) => (int)value, + (int value) => (WritingSystemType)value), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonInt32ReaderWriter.Instance, + new ValueConverter( + (WritingSystemType value) => (int)value, + (int value) => (WritingSystemType)value))); + type.SetSentinelFromProviderValue(0); + + var wsId = runtimeEntityType.AddProperty( + "WsId", + typeof(WritingSystemId), + propertyInfo: typeof(WritingSystem).GetProperty("WsId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(WritingSystem).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new LcmCrdtDbContext.WritingSystemIdConverter()); + wsId.TypeMapping = SqliteStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + (WritingSystemId v1, WritingSystemId v2) => v1.Equals(v2), + (WritingSystemId v) => v.GetHashCode(), + (WritingSystemId v) => v), + keyComparer: new ValueComparer( + (WritingSystemId v1, WritingSystemId v2) => v1.Equals(v2), + (WritingSystemId v) => v.GetHashCode(), + (WritingSystemId v) => v), + providerValueComparer: new ValueComparer( + (string v1, string v2) => v1 == v2, + (string v) => v.GetHashCode(), + (string v) => v), + converter: new ValueConverter( + (WritingSystemId id) => id.Code, + (string code) => new WritingSystemId(code)), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (WritingSystemId id) => id.Code, + (string code) => new WritingSystemId(code)))); + wsId.SetSentinelFromProviderValue("default"); + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { snapshotId }, + unique: true); + + var index0 = runtimeEntityType.AddIndex( + new[] { wsId, type }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("SnapshotId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.SetNull, + unique: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "WritingSystem"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/backend/FwLite/LcmCrdt/Data/CompileModelCustomization.cs b/backend/FwLite/LcmCrdt/Data/CompileModelCustomization.cs new file mode 100644 index 0000000000..f09db6db9f --- /dev/null +++ b/backend/FwLite/LcmCrdt/Data/CompileModelCustomization.cs @@ -0,0 +1,79 @@ + +using System.Text.Json.Serialization.Metadata; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using SIL.Harmony.Changes; +using SIL.Harmony.Core; +using SIL.Harmony.Db; +using SIL.Harmony.Db.EntityConfig; + +namespace LcmCrdt.CompiledModels; + +partial class ChangeEntityEntityType +{ + static partial void Customize(RuntimeEntityType runtimeEntityType) + { + var changeProperty = runtimeEntityType.FindProperty(nameof(ChangeEntity.Change)); + if (changeProperty == null) + { + throw new InvalidOperationException($"Change property not found on {nameof(ChangeEntity)}"); + } + + var config = LcmCrdtKernel.MakeConfig(); + var jsonSerializerOptions = config.JsonSerializerOptions; + changeProperty.TypeMapping = changeProperty.TypeMapping.Clone( + converter: new ValueConverter( + (IChange change) => ChangeEntityConfig.SerializeChange(change, jsonSerializerOptions), + (string json) => ChangeEntityConfig.DeserializeChange(json, + jsonSerializerOptions)), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (IChange change) => ChangeEntityConfig.SerializeChange(change, + jsonSerializerOptions), + (string json) => ChangeEntityConfig.DeserializeChange(json, + jsonSerializerOptions))) + ); + } +} +partial class ObjectSnapshotEntityType +{ + static partial void Customize(RuntimeEntityType runtimeEntityType) + { + var entityProperty = runtimeEntityType.FindProperty(nameof(ObjectSnapshot.Entity)); + if (entityProperty == null) + { + throw new InvalidOperationException($"Entity property not found on {nameof(ObjectSnapshot)}"); + } + + var config = LcmCrdtKernel.MakeConfig(); + var jsonSerializerOptions = config.JsonSerializerOptions; + entityProperty.TypeMapping = entityProperty.TypeMapping.Clone( + converter: new ValueConverter( + (IObjectBase obj) => SnapshotEntityConfig.Serialize(obj, jsonSerializerOptions), + (string json) => SnapshotEntityConfig.DeserializeObject(json, + jsonSerializerOptions)), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + (IObjectBase obj) => SnapshotEntityConfig.Serialize(obj, + jsonSerializerOptions), + (string json) => SnapshotEntityConfig.DeserializeObject(json, + jsonSerializerOptions))) + ); + + var referenceProperty = runtimeEntityType.FindProperty(nameof(ObjectSnapshot.References)); + if (referenceProperty == null) + { + throw new InvalidOperationException($"References property not found on {nameof(ObjectSnapshot)}"); + } + + var clrType = referenceProperty.TypeMapping.ElementTypeMapping?.ClrType; + if (clrType == null) + { + throw new InvalidOperationException($"Element type mapping not found on {nameof(ObjectSnapshot.References)}"); + } + referenceProperty.SetElementType(clrType, typeMapping: referenceProperty.TypeMapping.ElementTypeMapping, primitiveCollection: true); + } +} diff --git a/backend/FwLite/LcmCrdt/Json.cs b/backend/FwLite/LcmCrdt/Json.cs index d234432674..2d95959427 100644 --- a/backend/FwLite/LcmCrdt/Json.cs +++ b/backend/FwLite/LcmCrdt/Json.cs @@ -190,11 +190,4 @@ private record JsonEach( [property: Column("id")] int Id, [property: Column("fullkey")] string FullKey, [property: Column("path")] string Path); - - public static IJsonTypeInfoResolver MakeLcmCrdtExternalJsonTypeResolver(this CrdtConfig config) - { - var resolver = config.MakeJsonTypeResolver(); - resolver = resolver.AddExternalMiniLcmModifiers(); - return resolver; - } } diff --git a/backend/FwLite/LcmCrdt/JsonSourceGenerationContext.cs b/backend/FwLite/LcmCrdt/JsonSourceGenerationContext.cs new file mode 100644 index 0000000000..d54184715b --- /dev/null +++ b/backend/FwLite/LcmCrdt/JsonSourceGenerationContext.cs @@ -0,0 +1,72 @@ +using System.Text.Json.Serialization; +using LcmCrdt.Changes; +using LcmCrdt.Changes.Entries; +using LcmCrdt.Objects; +using SIL.Harmony; +using SIL.Harmony.Changes; +using SIL.Harmony.Core; +using SIL.Harmony.Db; + +namespace LcmCrdt; + +[JsonSourceGenerationOptions] +[JsonSerializable(typeof(WritingSystem))] +[JsonSerializable(typeof(MiniLcmCrdtAdapter))] +[JsonSerializable(typeof(IObjectWithId))] +[JsonSerializable(typeof(IObjectBase))] +[JsonSerializable(typeof(Dictionary))] +[JsonSerializable(typeof(Commit))] +[JsonSerializable(typeof(ObjectSnapshot))] +[JsonSerializable(typeof(Entry))] +[JsonSerializable(typeof(Sense))] +[JsonSerializable(typeof(List))] +[JsonSerializable(typeof(IList))] +[JsonSerializable(typeof(List))] +[JsonSerializable(typeof(MultiString))] +[JsonSerializable(typeof(IDictionary))] +[JsonSerializable(typeof(Dictionary))] +[JsonSerializable(typeof(List))] +[JsonSerializable(typeof(List))] + +[JsonSerializable(typeof(CreateEntryChange))] +[JsonSerializable(typeof(CreateWritingSystemChange))] +[JsonSerializable(typeof(JsonPatchChange))] +[JsonSerializable(typeof(JsonPatchChange))] +[JsonSerializable(typeof(JsonPatchChange))] +[JsonSerializable(typeof(JsonPatchChange))] +[JsonSerializable(typeof(JsonPatchChange))] +[JsonSerializable(typeof(JsonPatchChange))] +[JsonSerializable(typeof(JsonPatchChange))] +[JsonSerializable(typeof(JsonPatchChange))] +[JsonSerializable(typeof(DeleteChange))] +[JsonSerializable(typeof(DeleteChange))] +[JsonSerializable(typeof(DeleteChange))] +[JsonSerializable(typeof(DeleteChange))] +[JsonSerializable(typeof(DeleteChange))] +[JsonSerializable(typeof(DeleteChange))] +[JsonSerializable(typeof(DeleteChange))] +[JsonSerializable(typeof(DeleteChange))] +[JsonSerializable(typeof(DeleteChange))] +[JsonSerializable(typeof(SetPartOfSpeechChange))] +[JsonSerializable(typeof(AddSemanticDomainChange))] +[JsonSerializable(typeof(RemoveSemanticDomainChange))] +[JsonSerializable(typeof(ReplaceSemanticDomainChange))] +[JsonSerializable(typeof(CreateEntryChange))] +[JsonSerializable(typeof(CreateSenseChange))] +[JsonSerializable(typeof(CreateExampleSentenceChange))] +[JsonSerializable(typeof(CreatePartOfSpeechChange))] +[JsonSerializable(typeof(CreateSemanticDomainChange))] +[JsonSerializable(typeof(CreateWritingSystemChange))] +[JsonSerializable(typeof(CreatePublicationChange))] +[JsonSerializable(typeof(AddComplexFormTypeChange))] +[JsonSerializable(typeof(AddEntryComponentChange))] +[JsonSerializable(typeof(RemoveComplexFormTypeChange))] +[JsonSerializable(typeof(SetComplexFormComponentChange))] +[JsonSerializable(typeof(CreateComplexFormType))] +[JsonSerializable(typeof(Changes.SetOrderChange))] +[JsonSerializable(typeof(Changes.SetOrderChange))] +[JsonSerializable(typeof(Changes.SetOrderChange))] +public partial class JsonSourceGenerationContext: JsonSerializerContext +{ + +} diff --git a/backend/FwLite/LcmCrdt/LcmCrdtDbContext.cs b/backend/FwLite/LcmCrdt/LcmCrdtDbContext.cs index cf4a8a9e14..9073111d48 100644 --- a/backend/FwLite/LcmCrdt/LcmCrdtDbContext.cs +++ b/backend/FwLite/LcmCrdt/LcmCrdtDbContext.cs @@ -1,9 +1,11 @@ using System.Text.Json; +using LcmCrdt.CompiledModels; using LcmCrdt.Data; using SIL.Harmony; using SIL.Harmony.Db; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Microsoft.EntityFrameworkCore.ValueGeneration; using Microsoft.Extensions.Options; namespace LcmCrdt; @@ -16,6 +18,7 @@ public class LcmCrdtDbContext(DbContextOptions dbContextOption protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder) { optionsBuilder.AddInterceptors(setupCollationInterceptor); + optionsBuilder.UseModel(LcmCrdtDbContextModel.Instance); } protected override void OnModelCreating(ModelBuilder modelBuilder) @@ -39,14 +42,26 @@ protected override void ConfigureConventions(ModelConfigurationBuilder builder) .HaveConversion(); } - private class MultiStringDbConverter() : ValueConverter( - mul => JsonSerializer.Serialize(mul, (JsonSerializerOptions?)null), - json => JsonSerializer.Deserialize(json, (JsonSerializerOptions?)null) ?? new()); - private class RichMultiStringDbConverter() : ValueConverter( - mul => JsonSerializer.Serialize(mul, (JsonSerializerOptions?)null), - json => JsonSerializer.Deserialize(json, (JsonSerializerOptions?)null) ?? new()); + internal class MultiStringDbConverter() : ValueConverter( + mul => Serialize(mul), + json => Deserialize(json) ?? new()); - private class WritingSystemIdConverter() : ValueConverter( + internal class RichMultiStringDbConverter() : ValueConverter( + mul => Serialize(mul), + json => Deserialize(json) ?? new()); + + internal class WritingSystemIdConverter() : ValueConverter( id => id.Code, code => new WritingSystemId(code)); + + internal static string Serialize(T value) + { + return JsonSerializer.Serialize(value, typeof(T), JsonSourceGenerationContext.Default); + } + + internal static T Deserialize(string value) where T : class + { + return JsonSerializer.Deserialize(value, typeof(T), JsonSourceGenerationContext.Default) as T ?? + throw new InvalidOperationException($"Failed to deserialize {typeof(T).Name}"); + } } diff --git a/backend/FwLite/LcmCrdt/LcmCrdtKernel.cs b/backend/FwLite/LcmCrdt/LcmCrdtKernel.cs index 3947f9b00a..0fd6cb276e 100644 --- a/backend/FwLite/LcmCrdt/LcmCrdtKernel.cs +++ b/backend/FwLite/LcmCrdt/LcmCrdtKernel.cs @@ -58,8 +58,7 @@ public static IServiceCollection AddLcmCrdtClient(this IServiceCollection servic { ContentSerializer = new SystemTextJsonContentSerializer(new(JsonSerializerDefaults.Web) { - TypeInfoResolver = provider.GetRequiredService>().Value - .MakeLcmCrdtExternalJsonTypeResolver() + TypeInfoResolver = provider.GetRequiredService>().Value.JsonSerializerOptions.TypeInfoResolver?.AddExternalMiniLcmModifiers() }) }); services.AddSingleton(); @@ -90,6 +89,24 @@ private static void ConfigureDbOptions(IServiceProvider provider, DbContextOptio nameof(Commit.HybridDateTime) + "." + nameof(HybridDateTime.Counter))) //tells linq2db to rewrite Sense.SemanticDomains, into Json.Query(Sense.SemanticDomains) .Entity().Property(s => s.SemanticDomains).HasAttribute(new ExpressionMethodAttribute(SenseSemanticDomainsExpression())) + //for some reason since we started using compiled models linq2db is not picking up the conversion from EF + //so we need to define it here also + .HasConversion( + list => LcmCrdtDbContext.Serialize(list), + json => LcmCrdtDbContext.Deserialize>(json) ?? new() + ) + .Entity() + .Property(e => e.ComplexFormTypes).HasConversion(list => LcmCrdtDbContext.Serialize(list), + json => LcmCrdtDbContext.Deserialize>(json) ?? new()) + .Property(e => e.PublishIn).HasConversion(list => LcmCrdtDbContext.Serialize(list), + json => string.IsNullOrWhiteSpace(json) + ? new() + : LcmCrdtDbContext.Deserialize>(json) ?? new()) + .Entity() + .Property(w => w.Exemplars) + .HasConversion(list => LcmCrdtDbContext.Serialize(list), + json => LcmCrdtDbContext.Deserialize(json) ?? + Array.Empty()) .Build(); mappingSchema.SetConvertExpression((WritingSystemId id) => new DataParameter { Value = id.Code, DataType = DataType.Text }); @@ -107,6 +124,13 @@ private static Expression>> SenseSemantic return s => Json.Query(Sql.Property>(s, nameof(Sense.SemanticDomains))); } + public static CrdtConfig MakeConfig() + { + var config = new CrdtConfig(); + ConfigureCrdt(config); + return config; + } + public static void ConfigureCrdt(CrdtConfig config) { @@ -128,15 +152,13 @@ public static void ConfigureCrdt(CrdtConfig config) builder .Property(e => e.ComplexFormTypes) .HasColumnType("jsonb") - .HasConversion(list => JsonSerializer.Serialize(list, (JsonSerializerOptions?)null), - json => JsonSerializer.Deserialize>(json, - (JsonSerializerOptions?)null) ?? new()); + .HasConversion(list => LcmCrdtDbContext.Serialize(list), + json => LcmCrdtDbContext.Deserialize>(json) ?? new()); builder .Property(e => e.PublishIn) .HasColumnType("jsonb") - .HasConversion(list => JsonSerializer.Serialize(list, (JsonSerializerOptions?)null), - json => string.IsNullOrWhiteSpace(json) ? new() : JsonSerializer.Deserialize>(json, - (JsonSerializerOptions?)null) ?? new()); + .HasConversion(list => LcmCrdtDbContext.Serialize(list), + json => string.IsNullOrWhiteSpace(json) ? new() : LcmCrdtDbContext.Deserialize>(json) ?? new()); }) .Add(builder => { @@ -149,8 +171,8 @@ public static void ConfigureCrdt(CrdtConfig config) .HasForeignKey(sense => sense.EntryId); builder.Property(s => s.SemanticDomains) .HasColumnType("jsonb") - .HasConversion(list => JsonSerializer.Serialize(list, (JsonSerializerOptions?)null), - json => JsonSerializer.Deserialize>(json, (JsonSerializerOptions?)null) ?? new()); + .HasConversion(list => LcmCrdtDbContext.Serialize(list), + json => LcmCrdtDbContext.Deserialize>(json) ?? new()); }) .Add(builder => { @@ -160,11 +182,12 @@ public static void ConfigureCrdt(CrdtConfig config) }) .Add(builder => { + builder.Property(ws => ws.WsId).HasSentinel(new WritingSystemId("default")); builder.HasIndex(ws => new { ws.WsId, ws.Type }).IsUnique(); builder.Property(w => w.Exemplars) .HasColumnType("jsonb") - .HasConversion(list => JsonSerializer.Serialize(list, (JsonSerializerOptions?)null), - json => JsonSerializer.Deserialize(json, (JsonSerializerOptions?)null) ?? + .HasConversion(list => LcmCrdtDbContext.Serialize(list), + json => LcmCrdtDbContext.Deserialize(json) ?? Array.Empty()); }) .Add() @@ -230,6 +253,22 @@ public static void ConfigureCrdt(CrdtConfig config) // When adding anything other than a Delete or JsonPatch change, // you must add an instance of it to UseChangesTests.GetAllChanges() ; + + config.JsonSerializerOptions.TypeInfoResolver = JsonTypeInfoResolver.Combine(config.JsonSerializerOptions.TypeInfoResolver, JsonSourceGenerationContext.Default) + //per https://github.com/dotnet/runtime/issues/95893, source generators don't support custom converters per property + .WithAddedModifier(SetSensePosTypeConverter); + } + + public static void SetSensePosTypeConverter(JsonTypeInfo info) + { + if (info.Type != typeof(Sense)) + { + return; + } + + var partOfSpeechProperty = info.Properties.FirstOrDefault(p => p.PropertyType == typeof(PartOfSpeech)); + if (partOfSpeechProperty is null || partOfSpeechProperty.CustomConverter is not null) return; + partOfSpeechProperty.CustomConverter = new SensePoSConverter(); } public static IEnumerable AllChangeTypes() diff --git a/backend/FwLite/MiniLcm/Models/Sense.cs b/backend/FwLite/MiniLcm/Models/Sense.cs index ca0dbd650d..f1d2f8390a 100644 --- a/backend/FwLite/MiniLcm/Models/Sense.cs +++ b/backend/FwLite/MiniLcm/Models/Sense.cs @@ -53,7 +53,7 @@ public Sense Copy() } } -internal class SensePoSConverter : JsonConverter +public class SensePoSConverter : JsonConverter { public override PartOfSpeech? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) { diff --git a/backend/FwLite/Taskfile.yml b/backend/FwLite/Taskfile.yml index 6f23c69547..1159f52f84 100644 --- a/backend/FwLite/Taskfile.yml +++ b/backend/FwLite/Taskfile.yml @@ -33,6 +33,10 @@ tasks: desc: 'Usage: task add-migration -- "MigrationName"' dir: ./LcmCrdt cmd: dotnet ef migrations add {{.CLI_ARGS}} + compile-db-model: + deps: [tool-restore] + dir: ./LcmCrdt + cmd: dotnet ef dbcontext optimize has-pending-model-changes: deps: [ tool-restore ] diff --git a/backend/harmony b/backend/harmony index e758fbebda..57ba93355c 160000 --- a/backend/harmony +++ b/backend/harmony @@ -1 +1 @@ -Subproject commit e758fbebda4e0f1aba4656ea64b7cda991fde2d2 +Subproject commit 57ba93355c0fcfd5c55ad88aacfb92e7bae5564e