diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 50696ebdd..0786730d6 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -29,15 +29,15 @@ jobs: fail-fast: false matrix: dbVersion: - - 8.0.36-mysql - - 11.2.2-mariadb - - 11.1.3-mariadb - - 11.0.4-mariadb - - 10.11.6-mariadb - - 10.10.7-mariadb - - 10.6.16-mariadb - - 10.5.23-mariadb - - 10.4.32-mariadb + - 8.4.3-mysql + - 8.0.40-mysql + - 11.6.2-mariadb + - 11.5.2-mariadb + - 11.4.4-mariadb + - 11.3.2-mariadb + - 10.11.10-mariadb + - 10.6.20-mariadb + - 10.5.27-mariadb os: - ubuntu-latest - windows-latest diff --git a/Dependencies.targets b/Dependencies.targets index 3096890f9..c4a2bba44 100644 --- a/Dependencies.targets +++ b/Dependencies.targets @@ -1,6 +1,6 @@ - [9.0.0-preview.1.24081.2,9.0.0-preview.1.999999] + [9.0.0,9.0.999] @@ -9,45 +9,49 @@ - - + + - - - - - - - - - - - - - - + + + + + + + + + + + + + + - - + + - - + + - - - - + + + + - - - - + + + + + + + + \ No newline at end of file diff --git a/Directory.Build.props b/Directory.Build.props index f46a57707..13a3ed118 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -26,11 +26,11 @@ net8.0 - net8.0 + net9.0 net8.0 - net8.0 + net9.0 net8.0 - net7.0 + net8.0 @@ -39,7 +39,7 @@ - + diff --git a/Version.props b/Version.props index 039a3a1e9..71ed64c8f 100644 --- a/Version.props +++ b/Version.props @@ -13,8 +13,8 @@ - "servicing" - EF Core release independent, code quality production ready, mainly bugfixes --> 9.0.0 - preview - 2 + alpha + 1 + $(NoWarn);CS1591 @@ -48,7 +50,6 @@ - diff --git a/src/EFCore.MySql/Infrastructure/MariaDbServerVersion.cs b/src/EFCore.MySql/Infrastructure/MariaDbServerVersion.cs index 749463457..f3025d9da 100644 --- a/src/EFCore.MySql/Infrastructure/MariaDbServerVersion.cs +++ b/src/EFCore.MySql/Infrastructure/MariaDbServerVersion.cs @@ -19,6 +19,11 @@ public class MariaDbServerVersion : ServerVersion public override ServerVersionSupport Supports { get; } + // MariaDB on Linux seems to be using uca1400 collations as the default for the utf8mb4 charset from 11.4.2 onwards, but MariaDB for + // Windows seems to be using it only in later minor versions. + public override string DefaultUtf8CsCollation => Version >= new Version(11, 4, 2) ? "utf8mb4_uca1400_as_cs" : "utf8mb4_bin"; + public override string DefaultUtf8CiCollation => Version >= new Version(11, 4, 2) ? "utf8mb4_uca1400_ai_ci" : "utf8mb4_general_ci"; + public MariaDbServerVersion(Version version) : base(version, ServerType.MariaDb) { @@ -64,7 +69,7 @@ internal MariaDbServerVersionSupport([NotNull] ServerVersion serverVersion) public override bool GeneratedColumns => ServerVersion.Version >= new Version(10, 2, 0); public override bool NullableGeneratedColumns => false; public override bool ParenthesisEnclosedGeneratedColumnExpressions => false; - public override bool DefaultCharSetUtf8Mb4 => false; + public override bool DefaultCharSetUtf8Mb4 => ServerVersion.Version >= new Version(11, 4, 2); public override bool DefaultExpression => false; public override bool AlternativeDefaultExpression => ServerVersion.Version >= new Version(10, 2, 7); public override bool SpatialIndexes => ServerVersion.Version >= new Version(10, 2, 2); @@ -91,6 +96,8 @@ internal MariaDbServerVersionSupport([NotNull] ServerVersion serverVersion) public override bool Values => ServerVersion.Version >= new Version(10, 3, 3); public override bool ValuesWithRows => false; public override bool WhereSubqueryReferencesOuterQuery => false; + public override bool FieldReferenceInTableValueConstructor => false; + public override bool CollationCharacterSetApplicabilityWithFullCollationNameColumn => ServerVersion.Version >= new Version(10, 10, 1); public override bool JsonTableImplementationStable => false; public override bool JsonTableImplementationWithoutMariaDbBugs => false; diff --git a/src/EFCore.MySql/Infrastructure/MySqlServerVersion.cs b/src/EFCore.MySql/Infrastructure/MySqlServerVersion.cs index b64d70fef..c0c548e7c 100644 --- a/src/EFCore.MySql/Infrastructure/MySqlServerVersion.cs +++ b/src/EFCore.MySql/Infrastructure/MySqlServerVersion.cs @@ -19,6 +19,9 @@ public class MySqlServerVersion : ServerVersion public override ServerVersionSupport Supports { get; } + public override string DefaultUtf8CsCollation => Supports.DefaultCharSetUtf8Mb4 ? "utf8mb4_0900_as_cs" : "utf8mb4_bin"; + public override string DefaultUtf8CiCollation => Supports.DefaultCharSetUtf8Mb4 ? "utf8mb4_0900_ai_ci" : "utf8mb4_general_ci"; + public MySqlServerVersion(Version version) : base(version, ServerType.MySql) { @@ -94,6 +97,8 @@ internal MySqlServerVersionSupport([NotNull] ServerVersion serverVersion) public override bool Values => false; public override bool ValuesWithRows => ServerVersion.Version >= new Version(8, 0, 19); public override bool WhereSubqueryReferencesOuterQuery => false; + public override bool FieldReferenceInTableValueConstructor => true; + public override bool CollationCharacterSetApplicabilityWithFullCollationNameColumn => false; public override bool JsonTableImplementationStable => false; public override bool JsonTableImplementationWithoutMySqlBugs => false; // Other non-fatal bugs regarding JSON_TABLE. diff --git a/src/EFCore.MySql/Infrastructure/ServerVersion.cs b/src/EFCore.MySql/Infrastructure/ServerVersion.cs index 2ed6a65c5..42c991138 100644 --- a/src/EFCore.MySql/Infrastructure/ServerVersion.cs +++ b/src/EFCore.MySql/Infrastructure/ServerVersion.cs @@ -38,8 +38,8 @@ protected ServerVersion(Version version, ServerType type, string typeIdentifier public virtual int MaxKeyLength => Supports.LargerKeyLength ? 3072 : 767; public virtual CharSet DefaultCharSet => Supports.DefaultCharSetUtf8Mb4 ? CharSet.Utf8Mb4 : CharSet.Latin1; - public virtual string DefaultUtf8CsCollation => Supports.DefaultCharSetUtf8Mb4 ? "utf8mb4_0900_as_cs" : "utf8mb4_bin"; - public virtual string DefaultUtf8CiCollation => Supports.DefaultCharSetUtf8Mb4 ? "utf8mb4_0900_ai_ci" : "utf8mb4_general_ci"; + public abstract string DefaultUtf8CsCollation { get; } + public abstract string DefaultUtf8CiCollation { get; } public override bool Equals(object obj) => obj is ServerVersion version && diff --git a/src/EFCore.MySql/Infrastructure/ServerVersionSupport.cs b/src/EFCore.MySql/Infrastructure/ServerVersionSupport.cs index 644309070..a6dfe2c8b 100644 --- a/src/EFCore.MySql/Infrastructure/ServerVersionSupport.cs +++ b/src/EFCore.MySql/Infrastructure/ServerVersionSupport.cs @@ -94,6 +94,8 @@ public virtual bool PropertyOrVersion(string propertyNameOrServerVersion) public virtual bool Values => false; public virtual bool ValuesWithRows => false; public virtual bool WhereSubqueryReferencesOuterQuery => false; + public virtual bool FieldReferenceInTableValueConstructor => false; + public virtual bool CollationCharacterSetApplicabilityWithFullCollationNameColumn => false; public virtual bool JsonTableImplementationStable => JsonTable; public virtual bool JsonTableImplementationWithoutMySqlBugs => JsonTable; diff --git a/src/EFCore.MySql/Migrations/Internal/MySqlHistoryRepository.cs b/src/EFCore.MySql/Migrations/Internal/MySqlHistoryRepository.cs index e77348d72..8d03a1dd7 100644 --- a/src/EFCore.MySql/Migrations/Internal/MySqlHistoryRepository.cs +++ b/src/EFCore.MySql/Migrations/Internal/MySqlHistoryRepository.cs @@ -4,8 +4,11 @@ using System; using System.Linq; using System.Text; +using System.Threading; +using System.Threading.Tasks; using JetBrains.Annotations; using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; using Microsoft.EntityFrameworkCore.Metadata; using Microsoft.EntityFrameworkCore.Metadata.Builders; using Microsoft.EntityFrameworkCore.Metadata.Conventions; @@ -28,6 +31,66 @@ public MySqlHistoryRepository([NotNull] HistoryRepositoryDependencies dependenci _sqlGenerationHelper = (MySqlSqlGenerationHelper)dependencies.SqlGenerationHelper; } + public override LockReleaseBehavior LockReleaseBehavior + => LockReleaseBehavior.Connection; + + public override IMigrationsDatabaseLock AcquireDatabaseLock() + { + Dependencies.MigrationsLogger.AcquiringMigrationLock(); + + Dependencies.RawSqlCommandBuilder + .Build(GetAcquireLockCommandSql()) + .ExecuteNonQuery(CreateRelationalCommandParameters()); + + return CreateMigrationDatabaseLock(); + } + + public override async Task AcquireDatabaseLockAsync(CancellationToken cancellationToken = default) + { + await Dependencies.RawSqlCommandBuilder + .Build(GetAcquireLockCommandSql()) + .ExecuteNonQueryAsync(CreateRelationalCommandParameters(), cancellationToken) + .ConfigureAwait(false); + + return CreateMigrationDatabaseLock(); + } + + /// + /// Returns the name of the database-wide for migrations. Currently, this is actully a database *server*-wide lock, so the lock + /// should contain the database name to make it more database specific. + /// + protected virtual string GetDatabaseLockName(string databaseName) + => $"__{databaseName}_EFMigrationsLock"; + + // We cannot use LOCK TABLES/UNLOCK TABLES, because we would need to know *all* the table we want to access by name beforehand, + // since after the LOCK TABLES statement has run, only the tables specified can be access and access to any other table results in + // an error. + // We use GET_LOCK()/RELEASE_LOCK() for now. We would like to not specify a timeout, because we cannot know how long the migration + // operations are supposed to take. However, while MySQL interprets negative timeout values as infinite, MariaDB does not. We + // therefore specify a very large timeout in seconds instead (currently 72 hours). If RELEASE_LOCK() is never called, the lock is automatically released + // when the session ends or is killed. This function pair is not bound to a database, but is a database server wide global mutex. We + // therefore explicitly use the database name as part of the lock name. + // If it turns out, that users want a replication-save method later, we could implement a locking table mechanism as Sqlite does. + private string GetAcquireLockCommandSql() + => $"SELECT GET_LOCK('{GetDatabaseLockName(Dependencies.Connection.DbConnection.Database)}', {60 * 60 * 24 * 3})"; + + private RelationalCommandParameterObject CreateRelationalCommandParameters() + => new( + Dependencies.Connection, + null, + null, + Dependencies.CurrentContext.Context, + Dependencies.CommandLogger, CommandSource.Migrations); + + private MySqlMigrationDatabaseLock CreateMigrationDatabaseLock() + => new( + this, + CreateReleaseLockCommand(), + CreateRelationalCommandParameters()); + + private IRelationalCommand CreateReleaseLockCommand() + => Dependencies.RawSqlCommandBuilder.Build($"SELECT RELEASE_LOCK('{GetDatabaseLockName(Dependencies.Connection.DbConnection.Database)}')"); + protected override void ConfigureTable([NotNull] EntityTypeBuilder history) { base.ConfigureTable(history); @@ -175,5 +238,21 @@ protected override string ProductVersionColumnName .GetColumnName(); #endregion Necessary implementation because we cannot directly override EnsureModel + + private sealed class MySqlMigrationDatabaseLock( + MySqlHistoryRepository historyRepository, + IRelationalCommand releaseLockCommand, + RelationalCommandParameterObject relationalCommandParameters, + CancellationToken cancellationToken = default) + : IMigrationsDatabaseLock + { + public IHistoryRepository HistoryRepository => historyRepository; + + public void Dispose() + => releaseLockCommand.ExecuteScalar(relationalCommandParameters); + + public async ValueTask DisposeAsync() + => await releaseLockCommand.ExecuteScalarAsync(relationalCommandParameters, cancellationToken).ConfigureAwait(false); + } } } diff --git a/src/EFCore.MySql/Migrations/Internal/MySqlMigrator.cs b/src/EFCore.MySql/Migrations/Internal/MySqlMigrator.cs index 020cb96bc..a663c49f0 100644 --- a/src/EFCore.MySql/Migrations/Internal/MySqlMigrator.cs +++ b/src/EFCore.MySql/Migrations/Internal/MySqlMigrator.cs @@ -6,10 +6,10 @@ using System.Linq; using System.Text; using System.Text.RegularExpressions; -using JetBrains.Annotations; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Diagnostics; using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; using Microsoft.EntityFrameworkCore.Migrations; using Microsoft.EntityFrameworkCore.Migrations.Internal; using Microsoft.EntityFrameworkCore.Migrations.Operations; @@ -38,19 +38,23 @@ public class MySqlMigrator : Migrator private readonly IRelationalCommandDiagnosticsLogger _commandLogger; public MySqlMigrator( - [NotNull] IMigrationsAssembly migrationsAssembly, - [NotNull] IHistoryRepository historyRepository, - [NotNull] IDatabaseCreator databaseCreator, - [NotNull] IMigrationsSqlGenerator migrationsSqlGenerator, - [NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder, - [NotNull] IMigrationCommandExecutor migrationCommandExecutor, - [NotNull] IRelationalConnection connection, - [NotNull] ISqlGenerationHelper sqlGenerationHelper, - [NotNull] ICurrentDbContext currentContext, - [NotNull] IModelRuntimeInitializer modelRuntimeInitializer, - [NotNull] IDiagnosticsLogger logger, - [NotNull] IRelationalCommandDiagnosticsLogger commandLogger, - [NotNull] IDatabaseProvider databaseProvider) + IMigrationsAssembly migrationsAssembly, + IHistoryRepository historyRepository, + IDatabaseCreator databaseCreator, + IMigrationsSqlGenerator migrationsSqlGenerator, + IRawSqlCommandBuilder rawSqlCommandBuilder, + IMigrationCommandExecutor migrationCommandExecutor, + IRelationalConnection connection, + ISqlGenerationHelper sqlGenerationHelper, + ICurrentDbContext currentContext, + IModelRuntimeInitializer modelRuntimeInitializer, + IDiagnosticsLogger logger, + IRelationalCommandDiagnosticsLogger commandLogger, + IDatabaseProvider databaseProvider, + IMigrationsModelDiffer migrationsModelDiffer, + IDesignTimeModel designTimeModel, + IDbContextOptions contextOptions, + IExecutionStrategy executionStrategy) : base( migrationsAssembly, historyRepository, @@ -64,7 +68,11 @@ public MySqlMigrator( modelRuntimeInitializer, logger, commandLogger, - databaseProvider) + databaseProvider, + migrationsModelDiffer, + designTimeModel, + contextOptions, + executionStrategy) { _migrationsAssembly = migrationsAssembly; _rawSqlCommandBuilder = rawSqlCommandBuilder; @@ -145,13 +153,11 @@ protected virtual List GetAllMigrationOperations(string from PopulateMigrations( appliedMigrations, toMigration, - out var migrationsToApply, - out var migrationsToRevert, - out var actualTargetMigration); + out var migratorData); - return migrationsToApply + return migratorData.AppliedMigrations .SelectMany(x => x.UpOperations) - .Concat(migrationsToRevert.SelectMany(x => x.DownOperations)) + .Concat(migratorData.RevertedMigrations.SelectMany(x => x.DownOperations)) .ToList(); } diff --git a/src/EFCore.MySql/Migrations/MySqlMigrationsSqlGenerator.cs b/src/EFCore.MySql/Migrations/MySqlMigrationsSqlGenerator.cs index 390a17589..2ad1570a8 100644 --- a/src/EFCore.MySql/Migrations/MySqlMigrationsSqlGenerator.cs +++ b/src/EFCore.MySql/Migrations/MySqlMigrationsSqlGenerator.cs @@ -222,6 +222,31 @@ protected override void Generate( [NotNull] MigrationCommandListBuilder builder, bool terminate = true) { + // Create a unique constraint for an AUTO_INCREMENT column that is part of a compound primary key, but is not the first column + // in that key. In this case, for InnoDB to be satisfied, an index (preferably UNIQUE) with the AUTO_INCREMENT column as the first + // column, has to exists. + // + // TODO: Only add the column, if there is not an already existing index that has the AUTO_INCREMENT column as the first index. + // We should also monitor all related operations, to remove the index, if it is not needed anymore. + // Check/test, whether this does not only apply to primary keys, but also to other (alternate) ones as well, or is + // completely independent of keys, and really just applies to any AUTO_INCREMENT column. + // Also, move handling to conventions. + if (operation.PrimaryKey is { Columns.Length: > 1 } primaryKey && + primaryKey.Columns[0] is var firstPrimaryKeyColumnName && + operation.Columns.Single(c => c.Name == firstPrimaryKeyColumnName) is var firstPrimaryKeyColumn && + operation.Columns.FirstOrDefault(c => c[MySqlAnnotationNames.ValueGenerationStrategy] is MySqlValueGenerationStrategy.IdentityColumn) is { } autoIncrementColumn && + operation.Columns.Contains(autoIncrementColumn) && + autoIncrementColumn != firstPrimaryKeyColumn) + { + operation.UniqueConstraints.Add( + new AddUniqueConstraintOperation + { + Schema = operation.PrimaryKey.Schema, + Table = operation.PrimaryKey.Table, + Columns = [autoIncrementColumn.Name], + }); + } + base.Generate(operation, model, builder, false); var tableOptions = new List<(string, string)>(); @@ -301,17 +326,23 @@ protected override void Generate(AlterTableOperation operation, IModel model, Mi } else { + var collationColumnName = _options.ServerVersion.Supports.CollationCharacterSetApplicabilityWithFullCollationNameColumn + ? "FULL_COLLATION_NAME" + : "COLLATION_NAME"; + // The charset (and any collation) has been reset to the default. - var resetCharSetSql = $@"set @__pomelo_TableCharset = ( - SELECT `ccsa`.`CHARACTER_SET_NAME` as `TABLE_CHARACTER_SET` - FROM `INFORMATION_SCHEMA`.`TABLES` as `t` - LEFT JOIN `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`COLLATION_NAME` = `t`.`TABLE_COLLATION` - WHERE `TABLE_SCHEMA` = SCHEMA() AND `TABLE_NAME` = {_stringTypeMapping.GenerateSqlLiteral(operation.Name)} AND `TABLE_TYPE` IN ('BASE TABLE', 'VIEW')); + var resetCharSetSql = $""" +set @__pomelo_TableCharset = ( +SELECT `ccsa`.`CHARACTER_SET_NAME` as `TABLE_CHARACTER_SET` +FROM `INFORMATION_SCHEMA`.`TABLES` as `t` +LEFT JOIN `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`{collationColumnName}` = `t`.`TABLE_COLLATION` +WHERE `TABLE_SCHEMA` = SCHEMA() AND `TABLE_NAME` = {_stringTypeMapping.GenerateSqlLiteral(operation.Name)} AND `TABLE_TYPE` IN ('BASE TABLE', 'VIEW')); SET @__pomelo_SqlExpr = CONCAT('ALTER TABLE {Dependencies.SqlGenerationHelper.DelimitIdentifier(operation.Name)} CHARACTER SET = ', @__pomelo_TableCharset, ';'); PREPARE __pomelo_SqlExprExecute FROM @__pomelo_SqlExpr; EXECUTE __pomelo_SqlExprExecute; -DEALLOCATE PREPARE __pomelo_SqlExprExecute;"; +DEALLOCATE PREPARE __pomelo_SqlExprExecute; +"""; builder.AppendLine(resetCharSetSql); EndStatement(builder); @@ -1029,49 +1060,43 @@ protected override void Generate( EndStatement(builder); } - /// - /// Generates a SQL fragment configuring a sequence with the given options. - /// - /// The schema that contains the sequence, or to use the default schema. - /// The sequence name. - /// The sequence options. - /// The target model which may be if the operations exist without a model. - /// The command builder to use to add the SQL fragment. protected override void SequenceOptions( string schema, string name, SequenceOperation operation, IModel model, - MigrationCommandListBuilder builder) + MigrationCommandListBuilder builder, + bool forAlter) { - Check.NotEmpty(name, nameof(name)); - Check.NotNull(operation, nameof(operation)); - Check.NotNull(builder, nameof(builder)); + var intTypeMapping = Dependencies.TypeMappingSource.GetMapping(typeof(int)); + var longTypeMapping = Dependencies.TypeMappingSource.GetMapping(typeof(long)); builder .Append(" INCREMENT BY ") - .Append(IntegerConstant(operation.IncrementBy)); + .Append(intTypeMapping.GenerateSqlLiteral(operation.IncrementBy)); - if (operation.MinValue.HasValue) + if (operation.MinValue != null) { builder .Append(" MINVALUE ") - .Append(IntegerConstant(operation.MinValue.Value)); + .Append(longTypeMapping.GenerateSqlLiteral(operation.MinValue)); } - else + else if (forAlter) { - builder.Append(" NO MINVALUE"); + builder + .Append(" NO MINVALUE"); } - if (operation.MaxValue.HasValue) + if (operation.MaxValue != null) { builder .Append(" MAXVALUE ") - .Append(IntegerConstant(operation.MaxValue.Value)); + .Append(longTypeMapping.GenerateSqlLiteral(operation.MaxValue)); } - else + else if (forAlter) { - builder.Append(" NO MAXVALUE"); + builder + .Append(" NO MAXVALUE"); } builder.Append(operation.IsCyclic ? " CYCLE" : " NOCYCLE"); @@ -1459,47 +1484,16 @@ protected override void CreateTablePrimaryKeyConstraint( [CanBeNull] IModel model, [NotNull] MigrationCommandListBuilder builder) { - Check.NotNull(operation, nameof(operation)); - Check.NotNull(builder, nameof(builder)); - - var primaryKey = operation.PrimaryKey; - if (primaryKey != null) - { - builder.AppendLine(","); - - // MySQL InnoDB has the requirement, that an AUTO_INCREMENT column has to be the first - // column participating in an index. - - var sortedColumnNames = primaryKey.Columns.Length > 1 - ? primaryKey.Columns - .Select(columnName => operation.Columns.First(co => co.Name == columnName)) - .OrderBy(co => co[MySqlAnnotationNames.ValueGenerationStrategy] is MySqlValueGenerationStrategy generationStrategy - && generationStrategy == MySqlValueGenerationStrategy.IdentityColumn - ? 0 - : 1) - .Select(co => co.Name) - .ToArray() - : primaryKey.Columns; - - var sortedPrimaryKey = new AddPrimaryKeyOperation() - { - Schema = primaryKey.Schema, - Table = primaryKey.Table, - Name = primaryKey.Name, - Columns = sortedColumnNames, - IsDestructiveChange = primaryKey.IsDestructiveChange, - }; - - foreach (var annotation in primaryKey.GetAnnotations()) - { - sortedPrimaryKey[annotation.Name] = annotation.Value; - } - - PrimaryKeyConstraint( - sortedPrimaryKey, - model, - builder); - } + // We used to move an AUTO_INCREMENT column to the first position in a primary key, if the PK was a compound key and the column + // was not in the first position. We did this to satisfy InnoDB. + // However, this is technically an inaccuracy, and leads to incompatible FK -> PK mappings in MySQL 8.4. + // We will therefore reverse that behavior to leaving the key order unchanged again. + // This will lead to two issues: + // - Migrations that upgrade vom Pomelo < 9.0 to Pomelo 9.0 will not include this change automatically, because the model + // never changed (we only made the change (before and now) here in MySqlMigrationsSqlGenerator). + // - There now needs to be an index for those cases, that contains the AUTO_INCREMENT column as its first column. + + base.CreateTablePrimaryKeyConstraint(operation, model, builder); } protected override void PrimaryKeyConstraint( @@ -1679,7 +1673,7 @@ protected override void IndexTraits(MigrationOperation operation, IModel model, } } - protected override void IndexOptions(CreateIndexOperation operation, IModel model, MigrationCommandListBuilder builder) + protected override void IndexOptions(MigrationOperation operation, IModel model, MigrationCommandListBuilder builder) { // The base implementation supports index filters in form of a WHERE clause. // This is not supported by MySQL, so we don't call it here. diff --git a/src/EFCore.MySql/Query/ExpressionTranslators/Internal/MySqlJsonDbFunctionsTranslator.cs b/src/EFCore.MySql/Query/ExpressionTranslators/Internal/MySqlJsonDbFunctionsTranslator.cs index 81b77fa1d..0e4e4d73e 100644 --- a/src/EFCore.MySql/Query/ExpressionTranslators/Internal/MySqlJsonDbFunctionsTranslator.cs +++ b/src/EFCore.MySql/Query/ExpressionTranslators/Internal/MySqlJsonDbFunctionsTranslator.cs @@ -127,9 +127,10 @@ public virtual SqlExpression Translate( .Append(_sqlExpressionFactory.Constant("one")) .Append(args[1]) .AppendIfTrue( - args.Length >= 3, () => args.Length >= 4 + args.Length >= 3, + () => args.Length >= 4 ? args[3] - : _sqlExpressionFactory.Constant(null, RelationalTypeMapping.NullMapping)) + : _sqlExpressionFactory.Constant(null, typeof(string))) .AppendIfTrue(args.Length >= 3, () => args[2]), typeof(bool), null, diff --git a/src/EFCore.MySql/Query/ExpressionTranslators/Internal/MySqlStringComparisonMethodTranslator.cs b/src/EFCore.MySql/Query/ExpressionTranslators/Internal/MySqlStringComparisonMethodTranslator.cs index 3ee77e601..b11b50611 100644 --- a/src/EFCore.MySql/Query/ExpressionTranslators/Internal/MySqlStringComparisonMethodTranslator.cs +++ b/src/EFCore.MySql/Query/ExpressionTranslators/Internal/MySqlStringComparisonMethodTranslator.cs @@ -409,7 +409,7 @@ private SqlExpression MakeStartsWithEndsWithExpressionImpl( // in C# and send a simple LIKE. return constantPrefixSuffixExpression.Value switch { - null => _sqlExpressionFactory.Like(targetTransform(target), _sqlExpressionFactory.Constant(null, stringTypeMapping)), + null => _sqlExpressionFactory.Like(targetTransform(target), _sqlExpressionFactory.Constant(null, typeof(string), stringTypeMapping)), "" => _sqlExpressionFactory.Like(targetTransform(target), _sqlExpressionFactory.Constant("%")), string s => _sqlExpressionFactory.Like( targetTransform(target), @@ -472,7 +472,7 @@ private SqlExpression MakeContainsExpressionImpl( // in C# and send a simple LIKE. return constantPatternExpression.Value switch { - null => _sqlExpressionFactory.Like(targetTransform(target), _sqlExpressionFactory.Constant(null, stringTypeMapping)), + null => _sqlExpressionFactory.Like(targetTransform(target), _sqlExpressionFactory.Constant(null, typeof(string), stringTypeMapping)), "" => _sqlExpressionFactory.Like(targetTransform(target), _sqlExpressionFactory.Constant("%")), string s => _sqlExpressionFactory.Like( targetTransform(target), diff --git a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/BitwiseOperationReturnTypeCorrectingExpressionVisitor.cs b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/BitwiseOperationReturnTypeCorrectingExpressionVisitor.cs new file mode 100644 index 000000000..85adbc399 --- /dev/null +++ b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/BitwiseOperationReturnTypeCorrectingExpressionVisitor.cs @@ -0,0 +1,87 @@ +// Copyright (c) Pomelo Foundation. All rights reserved. +// Licensed under the MIT. See LICENSE in the project root for license information. + +using System.Linq.Expressions; +using Microsoft.EntityFrameworkCore.Query; +using Microsoft.EntityFrameworkCore.Query.SqlExpressions; +using Pomelo.EntityFrameworkCore.MySql.Query.Internal; + +namespace Pomelo.EntityFrameworkCore.MySql.Query.ExpressionVisitors.Internal; + +/// +/// MySQL implicitly casts numbers used in all bitwise operations to BIGINT UNSIGNED. +/// Bitwise operations are: +/// +/// +/// Operator +/// Description +/// +/// +/// & +/// Bitwise AND +/// +/// +/// >> +/// Right shift +/// +/// +/// << +/// Left shift +/// +/// +/// ^ +/// Bitwise OR +/// +/// +/// ~ +/// Bitwise inversion +/// +/// +/// We need to cast them back to their expected type. +/// +public class BitwiseOperationReturnTypeCorrectingExpressionVisitor : ExpressionVisitor +{ + private readonly MySqlSqlExpressionFactory _sqlExpressionFactory; + + public BitwiseOperationReturnTypeCorrectingExpressionVisitor(MySqlSqlExpressionFactory sqlExpressionFactory) + { + _sqlExpressionFactory = sqlExpressionFactory; + } + + protected override Expression VisitExtension(Expression extensionExpression) + => extensionExpression switch + { + SqlUnaryExpression unaryExpression => VisitUnary(unaryExpression), + SqlBinaryExpression binaryExpression => VisitBinary(binaryExpression), + ShapedQueryExpression shapedQueryExpression => shapedQueryExpression.UpdateQueryExpression(Visit(shapedQueryExpression.QueryExpression)), + _ => base.VisitExtension(extensionExpression) + }; + + protected virtual Expression VisitUnary(SqlUnaryExpression sqlUnaryExpression) + => base.VisitExtension(sqlUnaryExpression) is var visitedExpression && + visitedExpression is SqlUnaryExpression { OperatorType: ExpressionType.Not } visitedSqlUnaryExpression && + visitedSqlUnaryExpression.Type != typeof(bool) + ? _sqlExpressionFactory.Convert( + visitedSqlUnaryExpression, + visitedSqlUnaryExpression.Type, + visitedSqlUnaryExpression.TypeMapping) + : visitedExpression; + + protected virtual Expression VisitBinary(SqlBinaryExpression sqlBinaryExpression) + => base.VisitExtension(sqlBinaryExpression) is var visitedExpression && + visitedExpression is SqlBinaryExpression + { + OperatorType: ExpressionType.And + or ExpressionType.RightShift + or ExpressionType.LeftShift + or ExpressionType.ExclusiveOr + or ExpressionType.Or + or ExpressionType.Not + } visitedSqlBinaryExpression && + visitedSqlBinaryExpression.Type != typeof(bool) + ? _sqlExpressionFactory.Convert( + visitedSqlBinaryExpression, + visitedSqlBinaryExpression.Type, + visitedSqlBinaryExpression.TypeMapping) + : visitedExpression; +} diff --git a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlBoolOptimizingExpressionVisitor.cs b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlBoolOptimizingExpressionVisitor.cs index 2ca66b9cc..d3a08bd9e 100644 --- a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlBoolOptimizingExpressionVisitor.cs +++ b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlBoolOptimizingExpressionVisitor.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Linq.Expressions; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; @@ -244,7 +245,7 @@ protected override Expression VisitSelect(SelectExpression selectExpression) return changed ? selectExpression.Update( - projections, tables, predicate, groupBy, havingExpression, orderings, limit, offset) + tables, predicate, groupBy, havingExpression, projections, orderings, offset, limit) : selectExpression; } @@ -671,14 +672,25 @@ protected override Expression VisitValues(ValuesExpression valuesExpression) var parentOptimize = _optimize; _optimize = false; - var rowValues = new RowValueExpression[valuesExpression.RowValues.Count]; - for (var i = 0; i < rowValues.Length; i++) + switch (valuesExpression) { - rowValues[i] = (RowValueExpression)Visit(valuesExpression.RowValues[i]); - } + case { RowValues: not null }: + var rowValues = new RowValueExpression[valuesExpression.RowValues!.Count]; + for (var i = 0; i < rowValues.Length; i++) + { + rowValues[i] = (RowValueExpression)Visit(valuesExpression.RowValues[i]); + } + _optimize = parentOptimize; + return valuesExpression.Update(rowValues); - _optimize = parentOptimize; - return valuesExpression.Update(rowValues); + case { ValuesParameter: not null }: + var valuesParameter = (SqlParameterExpression)Visit(valuesExpression.ValuesParameter); + _optimize = parentOptimize; + return valuesExpression.Update(valuesParameter); + + default: + throw new UnreachableException(); + } } } } diff --git a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlHavingExpressionVisitor.cs b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlHavingExpressionVisitor.cs index b22dd1bb8..a6ca37788 100644 --- a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlHavingExpressionVisitor.cs +++ b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlHavingExpressionVisitor.cs @@ -8,81 +8,127 @@ using Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal; using Pomelo.EntityFrameworkCore.MySql.Query.Internal; -namespace Pomelo.EntityFrameworkCore.MySql.Query.ExpressionVisitors.Internal +namespace Pomelo.EntityFrameworkCore.MySql.Query.ExpressionVisitors.Internal; + +/// +/// MySQL & MariaDB currently do not support complex expressions in HAVING clauses (e.g. function calls). +/// Instead, they want you to reference SELECT aliases for those expressions in the HAVING clause. +/// See https://bugs.mysql.com/bug.php?id=103961 +/// This is only an issue for HAVING expressions that do not contain any aggregate functions. +/// +public class MySqlHavingExpressionVisitor : ExpressionVisitor { - public class MySqlHavingExpressionVisitor : ExpressionVisitor + private readonly MySqlSqlExpressionFactory _sqlExpressionFactory; + private readonly MySqlContainsAggregateFunctionExpressionVisitor _containsAggregateFunctionExpressionVisitor; + private bool _usePrePostprocessorMode; + + public MySqlHavingExpressionVisitor(MySqlSqlExpressionFactory sqlExpressionFactory) + { + _sqlExpressionFactory = sqlExpressionFactory; + _containsAggregateFunctionExpressionVisitor = new MySqlContainsAggregateFunctionExpressionVisitor(); + } + + public virtual Expression Process(Expression expression, bool usePrePostprocessorMode) { - private readonly MySqlSqlExpressionFactory _sqlExpressionFactory; - private MySqlContainsAggregateFunctionExpressionVisitor _containsAggregateFunctionExpressionVisitor; + _usePrePostprocessorMode = usePrePostprocessorMode; + return Visit(expression); + } - public MySqlHavingExpressionVisitor(MySqlSqlExpressionFactory sqlExpressionFactory) + protected override Expression VisitExtension(Expression extensionExpression) + => extensionExpression switch { - _sqlExpressionFactory = sqlExpressionFactory; + SelectExpression selectExpression => VisitSelect(selectExpression), + ShapedQueryExpression shapedQueryExpression => VisitShapedQuery(shapedQueryExpression), + RelationalGroupByShaperExpression relationalGroupByShaperExpression => VisitRelationalGroupByShaper( + relationalGroupByShaperExpression), + _ => base.VisitExtension(extensionExpression) + }; + + private Expression VisitRelationalGroupByShaper(RelationalGroupByShaperExpression relationalGroupByShaperExpression) + { + if (_usePrePostprocessorMode) + { + Visit(relationalGroupByShaperExpression.KeySelector); + Visit(relationalGroupByShaperExpression.ElementSelector); + Visit(relationalGroupByShaperExpression.GroupingEnumerable); + + return relationalGroupByShaperExpression; } - protected override Expression VisitExtension(Expression extensionExpression) - => extensionExpression switch - { - SelectExpression selectExpression => VisitSelect(selectExpression), - ShapedQueryExpression shapedQueryExpression => shapedQueryExpression.Update( - Visit(shapedQueryExpression.QueryExpression), Visit(shapedQueryExpression.ShaperExpression)), - _ => base.VisitExtension(extensionExpression) - }; + return base.VisitExtension(relationalGroupByShaperExpression); + } + + private ShapedQueryExpression VisitShapedQuery(ShapedQueryExpression shapedQueryExpression) + { + if (_usePrePostprocessorMode) + { + Visit(shapedQueryExpression.QueryExpression); + Visit(shapedQueryExpression.ShaperExpression); - protected virtual Expression VisitSelect(SelectExpression selectExpression) + return shapedQueryExpression; + } + + return shapedQueryExpression.Update( + Visit(shapedQueryExpression.QueryExpression), + Visit(shapedQueryExpression.ShaperExpression)); + } + + protected virtual Expression VisitSelect(SelectExpression selectExpression) + { + selectExpression = (SelectExpression)base.VisitExtension(selectExpression); + + var havingExpression = selectExpression.Having; + + if (HasHavingExpressionWithoutAggregateFunction(havingExpression)) { - // MySQL & MariaDB currently do not support complex expressions in HAVING clauses (e.g. function calls). - // Instead, they want you to reference SELECT aliases for those expressions in the HAVING clause. - // See https://bugs.mysql.com/bug.php?id=103961 - // This is only an issue for HAVING expressions that do not contain any aggregate functions. - var havingExpression = selectExpression.Having; - if (havingExpression is not null && - havingExpression is not SqlConstantExpression && - havingExpression is not MySqlColumnAliasReferenceExpression) + if (_usePrePostprocessorMode) { - _containsAggregateFunctionExpressionVisitor ??= new MySqlContainsAggregateFunctionExpressionVisitor(); - if (!_containsAggregateFunctionExpressionVisitor.ProcessUntilSelect(havingExpression)) - { - selectExpression.PushdownIntoSubquery(); - var subQuery = (SelectExpression) selectExpression.Tables.Single(); - - var projectionIndex = subQuery.AddToProjection(havingExpression); - var alias = subQuery.Projection[projectionIndex].Alias; - - var columnAliasReferenceExpression = _sqlExpressionFactory.ColumnAliasReference( - alias, - havingExpression, - havingExpression.Type, - havingExpression.TypeMapping); - - // Having expressions, not containing an aggregate function, need to be part of the GROUP BY clause, because they now also - // appear as part of the SELECT clause. - var groupBy = subQuery.GroupBy.ToList(); - groupBy.Add(columnAliasReferenceExpression); - - subQuery = subQuery.Update( - subQuery.Projection, - subQuery.Tables, - subQuery.Predicate, - groupBy, - columnAliasReferenceExpression, - subQuery.Orderings, - subQuery.Limit, - subQuery.Offset); - - selectExpression = selectExpression.Update( - selectExpression.Projection, - new[] {subQuery}, - selectExpression.Predicate, - selectExpression.GroupBy, - selectExpression.Having, - selectExpression.Orderings, - selectExpression.Limit, - selectExpression.Offset); - } + // This part needs to run before `RelationalQueryTranslationPostprocessor.Process()` is called, so that the + // `SelectExpression` is still mutable, and we can call `SelectExpression.PushdownIntoSubquery()`. + + selectExpression.PushdownIntoSubquery(); + + // Paradoxically, it seems quite complicated to change the subquery, as long as the outer query is still mutable. + // We postpone that work for later, when the outer query is immutable, and we simply use the normal expression visitor + // update process. } + else + { + // This part needs to run after `RelationalQueryTranslationPostprocessor.Process()` is called, so that the + // `SelectExpression` is already immutable, and we can simply update the select subquery. + + var projectionIndex = selectExpression.AddToProjection(havingExpression!); + var alias = selectExpression.Projection[projectionIndex].Alias; + + var columnAliasReferenceExpression = _sqlExpressionFactory.ColumnAliasReference( + alias, + havingExpression, + havingExpression.Type, + havingExpression.TypeMapping); - return base.VisitExtension(selectExpression); + // Having expressions, not containing an aggregate function, need to be part of the GROUP BY clause, because they now + // also appear as part of the SELECT clause. + selectExpression = selectExpression.Update( + selectExpression.Tables, + selectExpression.Predicate, + selectExpression.GroupBy.Append(columnAliasReferenceExpression).ToList(), + having: columnAliasReferenceExpression, + selectExpression.Projection, + selectExpression.Orderings, + selectExpression.Offset, + selectExpression.Limit); + } } + + return selectExpression; } + + /// + /// Backed by `EFCore.MySql.Tests/Behaviors/HavingBehavior.cs`. + /// + private bool HasHavingExpressionWithoutAggregateFunction(SqlExpression havingExpression) + => havingExpression is not null + and not SqlConstantExpression + and not MySqlColumnAliasReferenceExpression && + !_containsAggregateFunctionExpressionVisitor.ProcessUntilSelect(havingExpression); } diff --git a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlNonWorkingHavingExpressionVisitor.cs b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlNonWorkingHavingExpressionVisitor.cs new file mode 100644 index 000000000..de79b96c9 --- /dev/null +++ b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlNonWorkingHavingExpressionVisitor.cs @@ -0,0 +1,233 @@ +// Copyright (c) Pomelo Foundation. All rights reserved. +// Licensed under the MIT. See LICENSE in the project root for license information. + +using System.Linq; +using System.Linq.Expressions; +using Microsoft.EntityFrameworkCore.Query; +using Microsoft.EntityFrameworkCore.Query.SqlExpressions; +using Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal; +using Pomelo.EntityFrameworkCore.MySql.Query.Internal; + +namespace Pomelo.EntityFrameworkCore.MySql.Query.ExpressionVisitors.Internal +{ + // TODO: 9.0 + // Remove from codebase. + public class MySqlNonWorkingHavingExpressionVisitor : ExpressionVisitor + { + private readonly MySqlSqlExpressionFactory _sqlExpressionFactory; + private readonly SqlAliasManager _sqlAliasManager; + private MySqlContainsAggregateFunctionExpressionVisitor _containsAggregateFunctionExpressionVisitor; + + public MySqlNonWorkingHavingExpressionVisitor(MySqlSqlExpressionFactory sqlExpressionFactory, SqlAliasManager sqlAliasManager) + { + _sqlExpressionFactory = sqlExpressionFactory; + _sqlAliasManager = sqlAliasManager; + } + + protected override Expression VisitExtension(Expression extensionExpression) + => extensionExpression switch + { + SelectExpression selectExpression => VisitSelectMutable(selectExpression), + // SelectExpression selectExpression => VisitSelectImmutable(selectExpression), + ShapedQueryExpression shapedQueryExpression => VisitShapedQuery(shapedQueryExpression), + _ => base.VisitExtension(extensionExpression) + }; + + private ShapedQueryExpression VisitShapedQuery(ShapedQueryExpression shapedQueryExpression) + => shapedQueryExpression.Update( + (SelectExpression)Visit(shapedQueryExpression.QueryExpression), + Visit(shapedQueryExpression.ShaperExpression)); + + /// + /// This might work, if we would know if the outer query is supposed to be mutable or not (which we cannot directly find out + /// because `SelectExpression.IsMutable` is internal) and if we could copy or recreate the projection mappings of the outer query. + /// + protected virtual Expression VisitSelectMutable(SelectExpression selectExpression) + { + // MySQL & MariaDB currently do not support complex expressions in HAVING clauses (e.g. function calls). + // Instead, they want you to reference SELECT aliases for those expressions in the HAVING clause. + // See https://bugs.mysql.com/bug.php?id=103961 + // This is only an issue for HAVING expressions that do not contain any aggregate functions. + var havingExpression = selectExpression.Having; + if (havingExpression is not null && + havingExpression is not SqlConstantExpression && + havingExpression is not MySqlColumnAliasReferenceExpression) + { + _containsAggregateFunctionExpressionVisitor ??= new MySqlContainsAggregateFunctionExpressionVisitor(); + if (!_containsAggregateFunctionExpressionVisitor.ProcessUntilSelect(havingExpression)) + { + var newSelectExpression = selectExpression.Clone(); + + newSelectExpression.PushdownIntoSubquery(); + + var subQuery = (SelectExpression)newSelectExpression.Tables.Single(); + var projectionIndex = subQuery.AddToProjection(havingExpression); + var alias = subQuery.Projection[projectionIndex].Alias; + + var columnAliasReferenceExpression = _sqlExpressionFactory.ColumnAliasReference( + alias, + havingExpression, + havingExpression.Type, + havingExpression.TypeMapping); + + // Having expressions, not containing an aggregate function, need to be part of the GROUP BY clause, because they now also + // appear as part of the SELECT clause. + var groupBy = subQuery.GroupBy.ToList(); + groupBy.Add(columnAliasReferenceExpression); + + subQuery = new SelectExpression( + subQuery.Alias, + subQuery.Tables.ToList(), + subQuery.Predicate, + groupBy, + columnAliasReferenceExpression, + subQuery.Projection.ToList(), + subQuery.IsDistinct, + subQuery.Orderings.ToList(), + subQuery.Offset, + subQuery.Limit, + subQuery.Tags, + subQuery.GetAnnotations().ToDictionary(a => a.Name, a => a), + _sqlAliasManager, + isMutable: false + ); + + newSelectExpression = new SelectExpression( + newSelectExpression.Alias, + [subQuery], + newSelectExpression.Predicate, + newSelectExpression.GroupBy.ToList(), + newSelectExpression.Having, + projections: [], + newSelectExpression.IsDistinct, + newSelectExpression.Orderings.ToList(), + newSelectExpression.Offset, + newSelectExpression.Limit, + newSelectExpression.Tags, + newSelectExpression.GetAnnotations().ToDictionary(a => a.Name, a => a), + _sqlAliasManager, + isMutable: true + ); + + // + // UNSOLVED: Somehow recreate projection mappings here. + // + + selectExpression = newSelectExpression; + } + } + + return base.VisitExtension(selectExpression); + } + + /// + /// This basically needs to reimplement `SelectExpression.PushdownIntoSubquery()`, which we are definitely not going to do. + /// + protected virtual Expression VisitSelectImmutable(SelectExpression selectExpression) + { + // MySQL & MariaDB currently do not support complex expressions in HAVING clauses (e.g. function calls). + // Instead, they want you to reference SELECT aliases for those expressions in the HAVING clause. + // See https://bugs.mysql.com/bug.php?id=103961 + // This is only an issue for HAVING expressions that do not contain any aggregate functions. + var havingExpression = selectExpression.Having; + if (havingExpression is not null && + havingExpression is not SqlConstantExpression && + havingExpression is not MySqlColumnAliasReferenceExpression) + { + _containsAggregateFunctionExpressionVisitor ??= new MySqlContainsAggregateFunctionExpressionVisitor(); + if (!_containsAggregateFunctionExpressionVisitor.ProcessUntilSelect(havingExpression)) + { + var subquery = selectExpression.Clone(); + subquery.ReplaceProjection([]); + + var alias = "having"; + var havingProjectionExpression = new ProjectionExpression(havingExpression, alias); + var columnAliasReferenceExpression = _sqlExpressionFactory.ColumnAliasReference( + alias, + havingExpression, + havingExpression.Type, + havingExpression.TypeMapping); + + // Having expressions, not containing an aggregate function, need to be part of the GROUP BY clause, because they now also + // appear as part of the SELECT clause. + subquery = subquery.Update( + subquery.Tables, + subquery.Predicate, + subquery.GroupBy.Append(columnAliasReferenceExpression).ToList(), + columnAliasReferenceExpression, + subquery.Projection.Append(havingProjectionExpression).ToList(), + subquery.Limit is not null || subquery.Offset is not null + ? subquery.Orderings + : [], + subquery.Offset, // Offset/limit parameters got switched around between EF Core 8 and 9 for no good reason. + subquery.Limit); + + + var outerSelectOrderings = selectExpression.Orderings; + + // foreach (var ordering in subquery.Orderings) + // { + // var orderingExpression = ordering.Expression; + // if (liftOrderings && projectionMap.TryGetValue(orderingExpression, out var outerColumn)) + // { + // _orderings.Add(ordering.Update(outerColumn)); + // } + // else if (liftOrderings + // && (!IsDistinct + // && GroupBy.Count == 0 + // || GroupBy.Contains(orderingExpression))) + // { + // _orderings.Add( + // ordering.Update( + // subquery.GenerateOuterColumn(subqueryAlias, orderingExpression))); + // } + // else + // { + // _orderings.Clear(); + // break; + // } + // } + + + selectExpression = selectExpression.Update( + [subquery], + selectExpression.Predicate, + groupBy: [], + having: null, + subquery.Projection/*.Select(p => new ProjectionExpression(new ColumnExpression(p.Alias, subquery.Alias, p.Type, null)))*/, + outerSelectOrderings, + null, + null); + } + } + + return base.VisitExtension(selectExpression); + } + + // private ColumnExpression GenerateOuterColumn( + // SelectExpression subquery, + // string tableAlias, + // SqlExpression projection/*, + // string columnAlias = null*/) + // { + // // TODO: Add check if we can add projection in subquery to generate out column + // // Subquery having Distinct or GroupBy can block it. + // var index = subquery.AddToProjection(projection); + // var projectionExpression = subquery.Projection[index]; + // return CreateColumnExpression(projectionExpression, tableAlias); + // } + // + // private static ColumnExpression CreateColumnExpression(ProjectionExpression subqueryProjection, string tableAlias) + // => new( + // subqueryProjection.Alias, + // tableAlias, + // subqueryProjection.Type, + // subqueryProjection.Expression.TypeMapping!, + // subqueryProjection.Expression switch + // { + // ColumnExpression columnExpression => columnExpression.IsNullable, + // SqlConstantExpression sqlConstantExpression => sqlConstantExpression.Value == null, + // _ => true + // }); + } +} diff --git a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlParameterInliningExpressionVisitor.cs b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlParameterInliningExpressionVisitor.cs index 2d3885cc5..da9be518d 100644 --- a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlParameterInliningExpressionVisitor.cs +++ b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlParameterInliningExpressionVisitor.cs @@ -107,7 +107,7 @@ protected virtual Expression VisitSqlParameter(SqlParameterExpression sqlParamet return new MySqlInlinedParameterExpression( sqlParameterExpression, - _sqlExpressionFactory.Constant( + (SqlConstantExpression)_sqlExpressionFactory.Constant( _parametersValues[sqlParameterExpression.Name], sqlParameterExpression.TypeMapping)); } diff --git a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQuerySqlGenerator.cs b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQuerySqlGenerator.cs index e6344f625..c86ad0e9e 100644 --- a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQuerySqlGenerator.cs +++ b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQuerySqlGenerator.cs @@ -400,7 +400,7 @@ protected override Expression VisitDelete(DeleteExpression deleteExpression) } throw new InvalidOperationException( - RelationalStrings.ExecuteOperationWithUnsupportedOperatorInSqlGeneration(nameof(RelationalQueryableExtensions.ExecuteDelete))); + RelationalStrings.ExecuteOperationWithUnsupportedOperatorInSqlGeneration(nameof(EntityFrameworkQueryableExtensions.ExecuteDelete))); } protected override Expression VisitUpdate(UpdateExpression updateExpression) @@ -468,7 +468,7 @@ protected override Expression VisitUpdate(UpdateExpression updateExpression) } throw new InvalidOperationException( - RelationalStrings.ExecuteOperationWithUnsupportedOperatorInSqlGeneration(nameof(RelationalQueryableExtensions.ExecuteUpdate))); + RelationalStrings.ExecuteOperationWithUnsupportedOperatorInSqlGeneration(nameof(EntityFrameworkQueryableExtensions.ExecuteUpdate))); } protected override Expression VisitJsonScalar(JsonScalarExpression jsonScalarExpression) @@ -536,6 +536,11 @@ protected override Expression VisitJsonScalar(JsonScalarExpression jsonScalarExp protected override void GenerateValues(ValuesExpression valuesExpression) { + if (valuesExpression.RowValues is null) + { + throw new UnreachableException(); + } + if (_options.ServerVersion.Supports.Values || _options.ServerVersion.Supports.ValuesWithRows) { diff --git a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQueryTranslationPostprocessor.cs b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQueryTranslationPostprocessor.cs index ed219a6ed..cb0956c07 100644 --- a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQueryTranslationPostprocessor.cs +++ b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQueryTranslationPostprocessor.cs @@ -27,8 +27,15 @@ public MySqlQueryTranslationPostprocessor( public override Expression Process(Expression query) { + var mySqlHavingExpressionVisitor = new MySqlHavingExpressionVisitor(_sqlExpressionFactory); + + query = mySqlHavingExpressionVisitor.Process(query, usePrePostprocessorMode: true); + + // Changes `SelectExpression.IsMutable` from `true` to `false`. query = base.Process(query); + query = mySqlHavingExpressionVisitor.Process(query, usePrePostprocessorMode: false); + query = new MySqlJsonParameterExpressionVisitor(_sqlExpressionFactory, _options).Visit(query); if (_options.ServerVersion.Supports.MySqlBug96947Workaround) @@ -36,6 +43,8 @@ public override Expression Process(Expression query) query = new MySqlBug96947WorkaroundExpressionVisitor(_sqlExpressionFactory).Visit(query); } + query = new BitwiseOperationReturnTypeCorrectingExpressionVisitor(_sqlExpressionFactory).Visit(query); + return query; } } diff --git a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQueryableMethodNormalizingExpressionVisitor.cs b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQueryableMethodNormalizingExpressionVisitor.cs index bd0773c89..5b5998738 100644 --- a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQueryableMethodNormalizingExpressionVisitor.cs +++ b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlQueryableMethodNormalizingExpressionVisitor.cs @@ -10,6 +10,10 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.ExpressionVisitors.Internal; +// TODO: 9.0 +// Remove MySqlQueryableMethodNormalizingExpressionVisitor, MySqlBipolarExpression and +// MySqlQueryTranslationPreprocessor.NormalizeQueryableMethod (or the whole class) and use ElementAt() directly in Json translation classes. + /// /// Skips normalization of array[index].Property to array.Select(e => e.Property).ElementAt(index), /// because it messes-up our JSON-Array handling in `MySqlSqlTranslatingExpressionVisitor`. @@ -18,7 +22,7 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.ExpressionVisitors.Internal; public class MySqlQueryableMethodNormalizingExpressionVisitor : QueryableMethodNormalizingExpressionVisitor { public MySqlQueryableMethodNormalizingExpressionVisitor(QueryCompilationContext queryCompilationContext) - : base(queryCompilationContext) + : base(queryCompilationContext, isEfConstantSupported: true) { } @@ -75,7 +79,7 @@ IEnumerable VisitArguments(IEnumerable arguments) { foreach (var expression in arguments) { - yield return VisitExtension(expression); + yield return Visit(expression); } } diff --git a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlSqlTranslatingExpressionVisitor.cs b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlSqlTranslatingExpressionVisitor.cs index 312bfad58..b2922e35a 100644 --- a/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlSqlTranslatingExpressionVisitor.cs +++ b/src/EFCore.MySql/Query/ExpressionVisitors/Internal/MySqlSqlTranslatingExpressionVisitor.cs @@ -31,7 +31,8 @@ public class MySqlSqlTranslatingExpressionVisitor : RelationalSqlTranslatingExpr protected static readonly MethodInfo[] NewArrayExpressionSupportMethodInfos = Array.Empty() .Concat(typeof(MySqlDbFunctionsExtensions).GetRuntimeMethods().Where(m => m.Name is nameof(MySqlDbFunctionsExtensions.Match) or nameof(MySqlDbFunctionsExtensions.IsMatch))) - .Concat(typeof(string).GetRuntimeMethods().Where(m => m.Name == nameof(string.Concat))) + .Concat(typeof(string).GetRuntimeMethods().Where(m => m.Name is nameof(string.Concat) + or nameof(string.Join))) .Where(m => m.GetParameters().Any(p => p.ParameterType.IsArray)) .ToArray(); @@ -125,21 +126,7 @@ protected override Expression VisitUnary(UnaryExpression unaryExpression) ResetTranslationErrorDetails(); } - var visitedExpression = base.VisitUnary(unaryExpression); - - if (visitedExpression is SqlUnaryExpression sqlUnaryExpression && - sqlUnaryExpression.OperatorType == ExpressionType.Not && - sqlUnaryExpression.Type != typeof(bool)) - { - // MySQL implicitly casts numbers used in BITWISE NOT operations (~ operator) to BIGINT UNSIGNED. - // We need to cast them back, to get the expected result. - return _sqlExpressionFactory.Convert( - sqlUnaryExpression, - sqlUnaryExpression.Type, - sqlUnaryExpression.TypeMapping); - } - - return visitedExpression; + return base.VisitUnary(unaryExpression); } protected override Expression VisitBinary(BinaryExpression binaryExpression) @@ -306,7 +293,7 @@ private Expression TranslateByteArrayElementAccess(Expression array, Expression protected virtual Expression VisitMethodCallNewArray(NewArrayExpression newArrayExpression) { - // Needed for MySqlDbFunctionsExtensions.Match() and String.Concat() translation. + // Needed for MySqlDbFunctionsExtensions.Match(), String.Concat() and String.Join() translations. if (newArrayExpression.Type == typeof(string[])) { return _sqlExpressionFactory.ComplexFunctionArgument( @@ -316,7 +303,7 @@ protected virtual Expression VisitMethodCallNewArray(NewArrayExpression newArray typeof(string[])); } - // Needed for String.Concat() translation. + // Needed for String.Concat() and String.Join() translations. if (newArrayExpression.Type == typeof(object[])) { var typeMapping = ((MySqlStringTypeMapping)Dependencies.TypeMappingSource.GetMapping(typeof(string))).Clone(forceToString: true); @@ -435,6 +422,20 @@ protected virtual void ResetTranslationErrorDetails() base.Translate(Expression.Constant(0)); } + public override SqlExpression GenerateGreatest(IReadOnlyList expressions, Type resultType) + => _sqlExpressionFactory.NullableFunction( + "GREATEST", + expressions, + resultType, + true); + + public override SqlExpression GenerateLeast(IReadOnlyList expressions, Type resultType) + => _sqlExpressionFactory.NullableFunction( + "LEAST", + expressions, + resultType, + true); + #region Copied from RelationalSqlTranslatingExpressionVisitor private static Expression TryRemoveImplicitConvert(Expression expression) diff --git a/src/EFCore.MySql/Query/Expressions/Internal/MySqlBinaryExpression.cs b/src/EFCore.MySql/Query/Expressions/Internal/MySqlBinaryExpression.cs index c074afcad..0feba00f5 100644 --- a/src/EFCore.MySql/Query/Expressions/Internal/MySqlBinaryExpression.cs +++ b/src/EFCore.MySql/Query/Expressions/Internal/MySqlBinaryExpression.cs @@ -3,6 +3,7 @@ using System; using System.Linq.Expressions; +using System.Reflection; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; using Microsoft.EntityFrameworkCore.Storage; @@ -27,6 +28,8 @@ public enum MySqlBinaryExpressionOperatorType public class MySqlBinaryExpression : SqlExpression { + private static ConstructorInfo _quotingConstructor; + public MySqlBinaryExpression( MySqlBinaryExpressionOperatorType operatorType, SqlExpression left, @@ -61,6 +64,16 @@ protected override Expression VisitChildren(ExpressionVisitor visitor) return Update(left, right); } + public override Expression Quote() + => New( + _quotingConstructor ??= typeof(MySqlBinaryExpression).GetConstructor( + [typeof(MySqlBinaryExpressionOperatorType), typeof(SqlExpression), typeof(SqlExpression), typeof(Type), typeof(RelationalTypeMapping)])!, + Constant(OperatorType), + Left.Quote(), + Right.Quote(), + Constant(Type), + RelationalExpressionQuotingUtilities.QuoteTypeMapping(TypeMapping)); + public virtual MySqlBinaryExpression Update(SqlExpression left, SqlExpression right) => left != Left || right != Right ? new MySqlBinaryExpression(OperatorType, left, right, Type, TypeMapping) diff --git a/src/EFCore.MySql/Query/Expressions/Internal/MySqlCollateExpression.cs b/src/EFCore.MySql/Query/Expressions/Internal/MySqlCollateExpression.cs index 119c8c292..3d3532cfa 100644 --- a/src/EFCore.MySql/Query/Expressions/Internal/MySqlCollateExpression.cs +++ b/src/EFCore.MySql/Query/Expressions/Internal/MySqlCollateExpression.cs @@ -4,6 +4,7 @@ using System; using System.Linq; using System.Linq.Expressions; +using System.Reflection; using JetBrains.Annotations; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; @@ -17,6 +18,8 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal /// public class MySqlCollateExpression : SqlExpression { + private static ConstructorInfo _quotingConstructor; + private readonly SqlExpression _valueExpression; private readonly string _charset; private readonly string _collation; @@ -77,6 +80,15 @@ protected override Expression VisitChildren(ExpressionVisitor visitor) return Update(valueExpression); } + public override Expression Quote() + => New( + _quotingConstructor ??= typeof(MySqlInlinedParameterExpression).GetConstructor( + [typeof(SqlExpression), typeof(string), typeof(string), typeof(RelationalTypeMapping)])!, + ValueExpression.Quote(), + Constant(Charset), + Constant(Collation), + RelationalExpressionQuotingUtilities.QuoteTypeMapping(TypeMapping)); + public virtual MySqlCollateExpression Update(SqlExpression valueExpression) => valueExpression != _valueExpression && valueExpression != null diff --git a/src/EFCore.MySql/Query/Expressions/Internal/MySqlColumnAliasReferenceExpression.cs b/src/EFCore.MySql/Query/Expressions/Internal/MySqlColumnAliasReferenceExpression.cs index 70e184dc3..ecb40828a 100644 --- a/src/EFCore.MySql/Query/Expressions/Internal/MySqlColumnAliasReferenceExpression.cs +++ b/src/EFCore.MySql/Query/Expressions/Internal/MySqlColumnAliasReferenceExpression.cs @@ -3,6 +3,7 @@ using System; using System.Linq.Expressions; +using System.Reflection; using JetBrains.Annotations; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; @@ -15,6 +16,8 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal /// public class MySqlColumnAliasReferenceExpression : SqlExpression, IEquatable { + private static ConstructorInfo _quotingConstructor; + [NotNull] public virtual string Alias { get; } @@ -35,6 +38,15 @@ public MySqlColumnAliasReferenceExpression( protected override Expression VisitChildren(ExpressionVisitor visitor) => this; + public override Expression Quote() + => New( + _quotingConstructor ??= typeof(MySqlColumnAliasReferenceExpression).GetConstructor( + [typeof(string), typeof(SqlExpression), typeof(Type), typeof(RelationalTypeMapping)])!, + Constant(Alias), + Expression, + Constant(Type), + RelationalExpressionQuotingUtilities.QuoteTypeMapping(TypeMapping)); + public virtual MySqlColumnAliasReferenceExpression Update( [NotNull] string alias, [NotNull] SqlExpression expression) diff --git a/src/EFCore.MySql/Query/Expressions/Internal/MySqlComplexFunctionArgumentExpression.cs b/src/EFCore.MySql/Query/Expressions/Internal/MySqlComplexFunctionArgumentExpression.cs index 58ebb520e..92b0d359f 100644 --- a/src/EFCore.MySql/Query/Expressions/Internal/MySqlComplexFunctionArgumentExpression.cs +++ b/src/EFCore.MySql/Query/Expressions/Internal/MySqlComplexFunctionArgumentExpression.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; +using System.Reflection; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.Storage; @@ -14,6 +15,8 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal { public class MySqlComplexFunctionArgumentExpression : SqlExpression { + private static ConstructorInfo _quotingConstructor; + public MySqlComplexFunctionArgumentExpression( IEnumerable argumentParts, string delimiter, @@ -52,6 +55,16 @@ protected override Expression VisitChildren(ExpressionVisitor visitor) return Update(argumentParts, Delimiter); } + /// + public override Expression Quote() + => New( + _quotingConstructor ??= typeof(MySqlColumnAliasReferenceExpression).GetConstructor( + [typeof(IReadOnlyList), typeof(string), typeof(Type), typeof(RelationalTypeMapping)])!, + NewArrayInit(typeof(SqlExpression), ArgumentParts.Select(p => p.Quote())), + Constant(Delimiter), + Constant(Type), + RelationalExpressionQuotingUtilities.QuoteTypeMapping(TypeMapping)); + public virtual MySqlComplexFunctionArgumentExpression Update(IReadOnlyList argumentParts, string delimiter) => !argumentParts.SequenceEqual(ArgumentParts) ? new MySqlComplexFunctionArgumentExpression(argumentParts, delimiter, Type, TypeMapping) diff --git a/src/EFCore.MySql/Query/Expressions/Internal/MySqlInlinedParameterExpression.cs b/src/EFCore.MySql/Query/Expressions/Internal/MySqlInlinedParameterExpression.cs index 6824fa3e8..007bd8238 100644 --- a/src/EFCore.MySql/Query/Expressions/Internal/MySqlInlinedParameterExpression.cs +++ b/src/EFCore.MySql/Query/Expressions/Internal/MySqlInlinedParameterExpression.cs @@ -3,6 +3,7 @@ using System; using System.Linq.Expressions; +using System.Reflection; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; using Microsoft.EntityFrameworkCore.Utilities; @@ -11,6 +12,8 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal; public class MySqlInlinedParameterExpression : SqlExpression { + private static ConstructorInfo _quotingConstructor; + public MySqlInlinedParameterExpression( SqlParameterExpression parameterExpression, SqlConstantExpression valueExpression) @@ -22,7 +25,7 @@ public MySqlInlinedParameterExpression( ValueExpression = valueExpression; } - public virtual Expression ParameterExpression { get; } + public virtual SqlParameterExpression ParameterExpression { get; } public virtual SqlConstantExpression ValueExpression { get; } protected override Expression VisitChildren(ExpressionVisitor visitor) @@ -33,6 +36,14 @@ protected override Expression VisitChildren(ExpressionVisitor visitor) return Update(parameterExpression, valueExpression); } + /// + public override Expression Quote() + => New( + _quotingConstructor ??= typeof(MySqlInlinedParameterExpression).GetConstructor( + [typeof(SqlParameterExpression), typeof(SqlConstantExpression)])!, + ParameterExpression.Quote(), + ValueExpression.Quote()); + protected override void Print(ExpressionPrinter expressionPrinter) { expressionPrinter.Visit(ValueExpression); diff --git a/src/EFCore.MySql/Query/Expressions/Internal/MySqlJsonArrayIndexExpression.cs b/src/EFCore.MySql/Query/Expressions/Internal/MySqlJsonArrayIndexExpression.cs index c3a597ab3..e97c4e7cc 100644 --- a/src/EFCore.MySql/Query/Expressions/Internal/MySqlJsonArrayIndexExpression.cs +++ b/src/EFCore.MySql/Query/Expressions/Internal/MySqlJsonArrayIndexExpression.cs @@ -3,6 +3,7 @@ using System; using System.Linq.Expressions; +using System.Reflection; using JetBrains.Annotations; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; @@ -15,6 +16,8 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal /// public class MySqlJsonArrayIndexExpression : SqlExpression, IEquatable { + private static ConstructorInfo _quotingConstructor; + [NotNull] public virtual SqlExpression Expression { get; } @@ -30,6 +33,15 @@ public MySqlJsonArrayIndexExpression( protected override Expression VisitChildren(ExpressionVisitor visitor) => Update((SqlExpression)visitor.Visit(Expression)); + /// + public override Expression Quote() + => New( + _quotingConstructor ??= typeof(MySqlInlinedParameterExpression).GetConstructor( + [typeof(SqlExpression), typeof(Type), typeof(RelationalTypeMapping)])!, + Expression.Quote(), + Constant(Type), + RelationalExpressionQuotingUtilities.QuoteTypeMapping(TypeMapping)); + public virtual MySqlJsonArrayIndexExpression Update( [NotNull] SqlExpression expression) => expression == Expression diff --git a/src/EFCore.MySql/Query/Expressions/Internal/MySqlJsonTraversalExpression.cs b/src/EFCore.MySql/Query/Expressions/Internal/MySqlJsonTraversalExpression.cs index 68aed5a0c..194507529 100644 --- a/src/EFCore.MySql/Query/Expressions/Internal/MySqlJsonTraversalExpression.cs +++ b/src/EFCore.MySql/Query/Expressions/Internal/MySqlJsonTraversalExpression.cs @@ -5,6 +5,7 @@ using System.Collections.Generic; using System.Linq; using System.Linq.Expressions; +using System.Reflection; using JetBrains.Annotations; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; @@ -17,6 +18,8 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal /// public class MySqlJsonTraversalExpression : SqlExpression, IEquatable { + private static ConstructorInfo _quotingConstructor; + /// /// The JSON column. /// @@ -67,6 +70,16 @@ protected override Expression VisitChildren(ExpressionVisitor visitor) (SqlExpression)visitor.Visit(Expression), Path.Select(p => (SqlExpression)visitor.Visit(p)).ToArray()); + /// + public override Expression Quote() + => New( + _quotingConstructor ??= typeof(MySqlInlinedParameterExpression).GetConstructor( + [typeof(SqlExpression), typeof(IReadOnlyList), typeof(bool), typeof(Type), typeof(RelationalTypeMapping)])!, + Expression.Quote(), + NewArrayInit(typeof(SqlExpression), Path.Select(p => p.Quote())), + Constant(ReturnsText), + RelationalExpressionQuotingUtilities.QuoteTypeMapping(TypeMapping)); + public virtual MySqlJsonTraversalExpression Update( [NotNull] SqlExpression expression, [NotNull] IReadOnlyList path) diff --git a/src/EFCore.MySql/Query/Expressions/Internal/MySqlMatchExpression.cs b/src/EFCore.MySql/Query/Expressions/Internal/MySqlMatchExpression.cs index 28d823edd..bef262954 100644 --- a/src/EFCore.MySql/Query/Expressions/Internal/MySqlMatchExpression.cs +++ b/src/EFCore.MySql/Query/Expressions/Internal/MySqlMatchExpression.cs @@ -3,6 +3,7 @@ using System; using System.Linq.Expressions; +using System.Reflection; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; @@ -14,6 +15,8 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal { public class MySqlMatchExpression : SqlExpression { + private static ConstructorInfo _quotingConstructor; + public MySqlMatchExpression( SqlExpression match, SqlExpression against, @@ -51,6 +54,16 @@ protected override Expression VisitChildren(ExpressionVisitor visitor) return Update(match, against); } + /// + public override Expression Quote() + => New( + _quotingConstructor ??= typeof(MySqlInlinedParameterExpression).GetConstructor( + [typeof(SqlExpression), typeof(SqlExpression), typeof(MySqlMatchSearchMode), typeof(RelationalTypeMapping)])!, + Match.Quote(), + Against.Quote(), + Constant(SearchMode), + RelationalExpressionQuotingUtilities.QuoteTypeMapping(TypeMapping)); + public virtual MySqlMatchExpression Update(SqlExpression match, SqlExpression against) => match != Match || against != Against ? new MySqlMatchExpression( diff --git a/src/EFCore.MySql/Query/Expressions/Internal/MySqlRegexpExpression.cs b/src/EFCore.MySql/Query/Expressions/Internal/MySqlRegexpExpression.cs index 84d79ae51..6f7f0ceff 100644 --- a/src/EFCore.MySql/Query/Expressions/Internal/MySqlRegexpExpression.cs +++ b/src/EFCore.MySql/Query/Expressions/Internal/MySqlRegexpExpression.cs @@ -2,6 +2,7 @@ // Licensed under the MIT. See LICENSE in the project root for license information. using System.Linq.Expressions; +using System.Reflection; using JetBrains.Annotations; using Microsoft.EntityFrameworkCore.Utilities; using Microsoft.EntityFrameworkCore.Query.SqlExpressions; @@ -13,6 +14,8 @@ namespace Pomelo.EntityFrameworkCore.MySql.Query.Expressions.Internal { public class MySqlRegexpExpression : SqlExpression { + private static ConstructorInfo _quotingConstructor; + public MySqlRegexpExpression( [NotNull] SqlExpression match, [NotNull] SqlExpression pattern, @@ -46,6 +49,15 @@ protected override Expression VisitChildren(ExpressionVisitor visitor) return Update(match, pattern); } + /// + public override Expression Quote() + => New( + _quotingConstructor ??= typeof(MySqlInlinedParameterExpression).GetConstructor( + [typeof(SqlExpression), typeof(SqlExpression), typeof(RelationalTypeMapping)])!, + Match.Quote(), + Pattern.Quote(), + RelationalExpressionQuotingUtilities.QuoteTypeMapping(TypeMapping)); + public virtual MySqlRegexpExpression Update(SqlExpression match, SqlExpression pattern) => match != Match || pattern != Pattern diff --git a/src/EFCore.MySql/Query/Internal/MySqlDateTimeMethodTranslator.cs b/src/EFCore.MySql/Query/Internal/MySqlDateTimeMethodTranslator.cs index cff98cabb..4b178e61c 100644 --- a/src/EFCore.MySql/Query/Internal/MySqlDateTimeMethodTranslator.cs +++ b/src/EFCore.MySql/Query/Internal/MySqlDateTimeMethodTranslator.cs @@ -44,6 +44,8 @@ public class MySqlDateTimeMethodTranslator : IMethodCallTranslator private static readonly MethodInfo _timeOnlyAddTimeSpanMethod = typeof(TimeOnly).GetRuntimeMethod(nameof(TimeOnly.Add), new[] { typeof(TimeSpan) })!; private static readonly MethodInfo _timeOnlyIsBetweenMethod = typeof(TimeOnly).GetRuntimeMethod(nameof(TimeOnly.IsBetween), new[] { typeof(TimeOnly), typeof(TimeOnly) })!; + private static readonly MethodInfo _timeOnlyFromDateTimeMethod = typeof(TimeOnly).GetRuntimeMethod(nameof(TimeOnly.FromDateTime), new[] { typeof(DateTime) })!; + private static readonly MethodInfo _timeOnlyFromTimeSpanMethod = typeof(TimeOnly).GetRuntimeMethod(nameof(TimeOnly.FromTimeSpan), new[] { typeof(TimeSpan) })!; private static readonly MethodInfo _dateOnlyFromDateTimeMethod = typeof(DateOnly).GetRuntimeMethod(nameof(DateOnly.FromDateTime), new[] { typeof(DateTime) })!; private static readonly MethodInfo _dateOnlyToDateTimeMethod = typeof(DateOnly).GetRuntimeMethod(nameof(DateOnly.ToDateTime), new[] { typeof(TimeOnly) })!; @@ -137,11 +139,31 @@ public virtual SqlExpression Translate( _sqlExpressionFactory.GreaterThanOrEqual(instance, arguments[0]), _sqlExpressionFactory.LessThan(instance, arguments[1])); } + + if (instance is null && + arguments.Count == 1) + { + if (method == _timeOnlyFromDateTimeMethod) + { + return _sqlExpressionFactory.NullableFunction( + "TIME", + arguments, + typeof(TimeOnly), + onlyNullWhenAnyNullPropagatingArgumentIsNull: true); + } + + if (method == _timeOnlyFromTimeSpanMethod) + { + return _sqlExpressionFactory.Convert(arguments[0], method.ReturnType); + } + } } if (method.DeclaringType == typeof(DateOnly)) { - if (method == _dateOnlyFromDateTimeMethod) + if (method == _dateOnlyFromDateTimeMethod && + instance is null && + arguments.Count == 1) { return _sqlExpressionFactory.NullableFunction( "DATE", diff --git a/src/EFCore.MySql/Query/Internal/MySqlMathMethodTranslator.cs b/src/EFCore.MySql/Query/Internal/MySqlMathMethodTranslator.cs index b2f933d4c..f59230c39 100644 --- a/src/EFCore.MySql/Query/Internal/MySqlMathMethodTranslator.cs +++ b/src/EFCore.MySql/Query/Internal/MySqlMathMethodTranslator.cs @@ -63,21 +63,8 @@ public class MySqlMathMethodTranslator : IMethodCallTranslator { typeof(Math).GetRuntimeMethod(nameof(Math.Log10), new[] { typeof(double) }), ("LOG10", false, false) }, { typeof(MathF).GetRuntimeMethod(nameof(MathF.Log10), new[] { typeof(float) }), ("LOG10", false, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(decimal), typeof(decimal) }), ("GREATEST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(double), typeof(double) }), ("GREATEST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(float), typeof(float) }), ("GREATEST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(int), typeof(int) }), ("GREATEST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(long), typeof(long) }), ("GREATEST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Max), new[] { typeof(short), typeof(short) }), ("GREATEST", true, false) }, - { typeof(MathF).GetRuntimeMethod(nameof(MathF.Max), new[] { typeof(float), typeof(float) }), ("GREATEST", true, false) }, - - { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(decimal), typeof(decimal) }), ("LEAST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(double), typeof(double) }), ("LEAST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(float), typeof(float) }), ("LEAST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(int), typeof(int) }), ("LEAST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(long), typeof(long) }), ("LEAST", true, false) }, - { typeof(Math).GetRuntimeMethod(nameof(Math.Min), new[] { typeof(short), typeof(short) }), ("LEAST", true, false) }, - { typeof(MathF).GetRuntimeMethod(nameof(MathF.Min), new[] { typeof(float), typeof(float) }), ("LEAST", true, false) }, + // GREATEST is handled in MySqlSqlTranslatingExpressionVisitor.GenerateGreatest(): + // LEAST is handled in MySqlSqlTranslatingExpressionVisitor.GenerateLeast(): { typeof(Math).GetRuntimeMethod(nameof(Math.Pow), new[] { typeof(double), typeof(double) }), ("POWER", true, false) }, { typeof(MathF).GetRuntimeMethod(nameof(MathF.Pow), new[] { typeof(float), typeof(float) }), ("POWER", true, false) }, diff --git a/src/EFCore.MySql/Query/Internal/MySqlObjectToStringTranslator.cs b/src/EFCore.MySql/Query/Internal/MySqlObjectToStringTranslator.cs index 65cd340f9..473e1d64f 100644 --- a/src/EFCore.MySql/Query/Internal/MySqlObjectToStringTranslator.cs +++ b/src/EFCore.MySql/Query/Internal/MySqlObjectToStringTranslator.cs @@ -51,41 +51,49 @@ public virtual SqlExpression Translate( IReadOnlyList arguments, IDiagnosticsLogger logger) { - if (instance == null || - method.Name != nameof(ToString) || - arguments.Count != 0) + if (instance == null || method.Name != nameof(ToString) || arguments.Count != 0) { return null; } + if (instance.TypeMapping?.ClrType == typeof(string)) + { + return instance; + } + if (instance.Type == typeof(bool)) { - return instance is ColumnExpression columnExpression && - columnExpression.IsNullable - ? _sqlExpressionFactory.Case( + if (instance is not ColumnExpression { IsNullable: false }) + { + return _sqlExpressionFactory.Case( + instance, new[] { new CaseWhenClause( - _sqlExpressionFactory.Equal(instance, _sqlExpressionFactory.Constant(false)), + _sqlExpressionFactory.Constant(false), _sqlExpressionFactory.Constant(false.ToString())), new CaseWhenClause( - _sqlExpressionFactory.Equal(instance, _sqlExpressionFactory.Constant(true)), + _sqlExpressionFactory.Constant(true), _sqlExpressionFactory.Constant(true.ToString())) }, - _sqlExpressionFactory.Constant(null)) - : _sqlExpressionFactory.Case( - new[] - { - new CaseWhenClause( - _sqlExpressionFactory.Equal(instance, _sqlExpressionFactory.Constant(false)), - _sqlExpressionFactory.Constant(false.ToString())) - }, - _sqlExpressionFactory.Constant(true.ToString())); + _sqlExpressionFactory.Constant(string.Empty)); + } + + return _sqlExpressionFactory.Case( + new[] + { + new CaseWhenClause( + instance, + _sqlExpressionFactory.Constant(true.ToString())) + }, + _sqlExpressionFactory.Constant(false.ToString())); } - // Translates parameterless Object.ToString() calls. - return _supportedTypes.Contains(instance.Type.UnwrapNullableType()) - ? _sqlExpressionFactory.Convert(instance, typeof(string)) + // Enums are handled by EnumMethodTranslator. + return _supportedTypes.Contains(instance.Type) + ? _sqlExpressionFactory.Coalesce( + _sqlExpressionFactory.Convert(instance, typeof(string)), + _sqlExpressionFactory.Constant(string.Empty)) : null; } } diff --git a/src/EFCore.MySql/Query/Internal/MySqlParameterBasedSqlProcessor.cs b/src/EFCore.MySql/Query/Internal/MySqlParameterBasedSqlProcessor.cs index c93b6ea9f..4111be0d1 100644 --- a/src/EFCore.MySql/Query/Internal/MySqlParameterBasedSqlProcessor.cs +++ b/src/EFCore.MySql/Query/Internal/MySqlParameterBasedSqlProcessor.cs @@ -18,9 +18,9 @@ public class MySqlParameterBasedSqlProcessor : RelationalParameterBasedSqlProces public MySqlParameterBasedSqlProcessor( RelationalParameterBasedSqlProcessorDependencies dependencies, - bool useRelationalNulls, + RelationalParameterBasedSqlProcessorParameters parameters, IMySqlOptions options) - : base(dependencies, useRelationalNulls) + : base(dependencies, parameters) { _options = options; } @@ -46,8 +46,6 @@ public override Expression Optimize( .Visit(queryExpression); } - queryExpression = new MySqlHavingExpressionVisitor((MySqlSqlExpressionFactory)Dependencies.SqlExpressionFactory).Visit(queryExpression); - queryExpression = new MySqlParameterInliningExpressionVisitor( Dependencies.TypeMappingSource, Dependencies.SqlExpressionFactory, @@ -70,7 +68,7 @@ protected override Expression ProcessSqlNullability( Check.NotNull(queryExpression, nameof(queryExpression)); Check.NotNull(parametersValues, nameof(parametersValues)); - queryExpression = new MySqlSqlNullabilityProcessor(Dependencies, UseRelationalNulls) + queryExpression = new MySqlSqlNullabilityProcessor(Dependencies, Parameters) .Process(queryExpression, parametersValues, out canCache); return queryExpression; diff --git a/src/EFCore.MySql/Query/Internal/MySqlParameterBasedSqlProcessorFactory.cs b/src/EFCore.MySql/Query/Internal/MySqlParameterBasedSqlProcessorFactory.cs index 0aeb6915e..4a2fc73db 100644 --- a/src/EFCore.MySql/Query/Internal/MySqlParameterBasedSqlProcessorFactory.cs +++ b/src/EFCore.MySql/Query/Internal/MySqlParameterBasedSqlProcessorFactory.cs @@ -20,7 +20,7 @@ public MySqlParameterBasedSqlProcessorFactory( _options = options; } - public virtual RelationalParameterBasedSqlProcessor Create(bool useRelationalNulls) - => new MySqlParameterBasedSqlProcessor(_dependencies, useRelationalNulls, _options); + public virtual RelationalParameterBasedSqlProcessor Create(RelationalParameterBasedSqlProcessorParameters parameters) + => new MySqlParameterBasedSqlProcessor(_dependencies, parameters, _options); } } diff --git a/src/EFCore.MySql/Query/Internal/MySqlQueryableMethodTranslatingExpressionVisitor.cs b/src/EFCore.MySql/Query/Internal/MySqlQueryableMethodTranslatingExpressionVisitor.cs index a16cc6f29..789df5247 100644 --- a/src/EFCore.MySql/Query/Internal/MySqlQueryableMethodTranslatingExpressionVisitor.cs +++ b/src/EFCore.MySql/Query/Internal/MySqlQueryableMethodTranslatingExpressionVisitor.cs @@ -2,7 +2,6 @@ // Licensed under the MIT. See LICENSE in the project root for license information. using System; -using System.Collections.Generic; using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Linq.Expressions; @@ -17,7 +16,6 @@ using Microsoft.EntityFrameworkCore.Utilities; using Pomelo.EntityFrameworkCore.MySql.Infrastructure.Internal; using Pomelo.EntityFrameworkCore.MySql.Query.ExpressionTranslators.Internal; -using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; namespace Pomelo.EntityFrameworkCore.MySql.Query.Internal; @@ -361,12 +359,6 @@ elementTypeMapping is not null return new ShapedQueryExpression(selectExpression, shaperExpression); } - protected override Expression ApplyInferredTypeMappings( - Expression expression, - IReadOnlyDictionary<(string, string), RelationalTypeMapping> inferredTypeMappings) - => new MySqlInferredTypeMappingApplier( - RelationalDependencies.Model, _typeMappingSource, _sqlExpressionFactory, inferredTypeMappings).Visit(expression); - /// /// Wraps the given expression with any SQL logic necessary to convert a value coming out of a JSON document into the relational value /// represented by the given type mapping. @@ -383,128 +375,6 @@ private static SqlExpression ApplyJsonSqlConversion( _ => expression }; - protected class MySqlInferredTypeMappingApplier : RelationalInferredTypeMappingApplier - { - private readonly IRelationalTypeMappingSource _typeMappingSource; - private readonly ISqlExpressionFactory _sqlExpressionFactory; - private Dictionary _currentSelectInferredTypeMappings; - - /// - /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to - /// the same compatibility standards as public APIs. It may be changed or removed without notice in - /// any release. You should only use it directly in your code with extreme caution and knowing that - /// doing so can result in application failures when updating to a new Entity Framework Core release. - /// - public MySqlInferredTypeMappingApplier( - IModel model, - IRelationalTypeMappingSource typeMappingSource, - ISqlExpressionFactory sqlExpressionFactory, - IReadOnlyDictionary<(string, string), RelationalTypeMapping> inferredTypeMappings) - : base(model, sqlExpressionFactory, inferredTypeMappings) - { - (_typeMappingSource, _sqlExpressionFactory) = (typeMappingSource, sqlExpressionFactory); - } - - /// - /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to - /// the same compatibility standards as public APIs. It may be changed or removed without notice in - /// any release. You should only use it directly in your code with extreme caution and knowing that - /// doing so can result in application failures when updating to a new Entity Framework Core release. - /// - protected override Expression VisitExtension(Expression expression) - { - switch (expression) - { - case MySqlJsonTableExpression { Name: "JSON_TABLE", Schema: null, IsBuiltIn: true } jsonTableExpression - when TryGetInferredTypeMapping(jsonTableExpression.Alias, "value", out var typeMapping): - return ApplyTypeMappingsOnJsonTableExpression(jsonTableExpression, typeMapping); - - // Above, we applied the type mapping the the parameter that JSON_TABLE accepts as an argument. - // But the inferred type mapping also needs to be applied as a SQL conversion on the column projections coming out of the - // SelectExpression containing the JSON_TABLE call. So we set state to know about JSON_TABLE tables and their type mappings - // in the immediate SelectExpression, and continue visiting down (see ColumnExpression visitation below). - case SelectExpression selectExpression: - { - Dictionary previousSelectInferredTypeMappings = null; - - foreach (var table in selectExpression.Tables) - { - if (table is TableValuedFunctionExpression { Name: "JSON_TABLE", Schema: null, IsBuiltIn: true } jsonTableExpression - && TryGetInferredTypeMapping(jsonTableExpression.Alias, "value", out var inferredTypeMapping)) - { - if (previousSelectInferredTypeMappings is null) - { - previousSelectInferredTypeMappings = _currentSelectInferredTypeMappings; - _currentSelectInferredTypeMappings = new Dictionary(); - } - - _currentSelectInferredTypeMappings![jsonTableExpression.Alias] = inferredTypeMapping; - } - } - - var visited = base.VisitExtension(expression); - - _currentSelectInferredTypeMappings = previousSelectInferredTypeMappings; - - return visited; - } - - // Note that we match also ColumnExpressions which already have a type mapping, i.e. coming out of column collections (as - // opposed to parameter collections, where the type mapping needs to be inferred). This is in order to apply SQL conversion - // logic later in the process, see note in TranslateCollection. - case ColumnExpression { Name: "value" } columnExpression - when _currentSelectInferredTypeMappings?.TryGetValue(columnExpression.TableAlias, out var inferredTypeMapping) is true: - return ApplyJsonSqlConversion( - columnExpression.ApplyTypeMapping(inferredTypeMapping), - _sqlExpressionFactory, - inferredTypeMapping, - columnExpression.IsNullable); - - default: - return base.VisitExtension(expression); - } - } - - /// - /// This is an internal API that supports the Entity Framework Core infrastructure and not subject to - /// the same compatibility standards as public APIs. It may be changed or removed without notice in - /// any release. You should only use it directly in your code with extreme caution and knowing that - /// doing so can result in application failures when updating to a new Entity Framework Core release. - /// - protected virtual TableValuedFunctionExpression ApplyTypeMappingsOnJsonTableExpression( - MySqlJsonTableExpression jsonTableExpression, - RelationalTypeMapping inferredTypeMapping) - { - // Constant queryables are translated to VALUES, no need for JSON. - // Column queryables have their type mapping from the model, so we don't ever need to apply an inferred mapping on them. - if (jsonTableExpression.JsonExpression is not SqlParameterExpression parameterExpression) - { - return jsonTableExpression; - } - - if (_typeMappingSource.FindMapping(parameterExpression.Type, Model, inferredTypeMapping) is not MySqlStringTypeMapping - parameterTypeMapping) - { - throw new InvalidOperationException("Type mapping for 'string' could not be found or was not a MySqlStringTypeMapping"); - } - - Check.DebugAssert(parameterTypeMapping.ElementTypeMapping != null, "Collection type mapping missing element mapping."); - - return jsonTableExpression.Update( - parameterExpression.ApplyTypeMapping(parameterTypeMapping), - jsonTableExpression.Path, - new[] - { - new MySqlJsonTableExpression.ColumnInfo - { - Name = "value", - TypeMapping = (RelationalTypeMapping)parameterTypeMapping.ElementTypeMapping, - Path = new[] { new PathSegment(_sqlExpressionFactory.Constant(0, _typeMappingSource.FindMapping(typeof(int)))) }, - } - }); - } - } - private sealed class FakeMemberInfo : MemberInfo { public FakeMemberInfo(string name) diff --git a/src/EFCore.MySql/Query/Internal/MySqlSqlNullabilityProcessor.cs b/src/EFCore.MySql/Query/Internal/MySqlSqlNullabilityProcessor.cs index 40f7daf62..ba7c868ca 100644 --- a/src/EFCore.MySql/Query/Internal/MySqlSqlNullabilityProcessor.cs +++ b/src/EFCore.MySql/Query/Internal/MySqlSqlNullabilityProcessor.cs @@ -20,11 +20,11 @@ public class MySqlSqlNullabilityProcessor : SqlNullabilityProcessor /// Creates a new instance of the class. /// /// Parameter object containing dependencies for this class. - /// A bool value indicating whether relational null semantics are in use. + /// Parameter object containing parameters for this class. public MySqlSqlNullabilityProcessor( [NotNull] RelationalParameterBasedSqlProcessorDependencies dependencies, - bool useRelationalNulls) - : base(dependencies, useRelationalNulls) + RelationalParameterBasedSqlProcessorParameters parameters) + : base(dependencies, parameters) => _sqlExpressionFactory = dependencies.SqlExpressionFactory; /// diff --git a/src/EFCore.MySql/Query/Internal/MySqlStringMemberTranslator.cs b/src/EFCore.MySql/Query/Internal/MySqlStringMemberTranslator.cs index 4e6031b4e..97fa57f75 100644 --- a/src/EFCore.MySql/Query/Internal/MySqlStringMemberTranslator.cs +++ b/src/EFCore.MySql/Query/Internal/MySqlStringMemberTranslator.cs @@ -26,7 +26,7 @@ public virtual SqlExpression Translate( IDiagnosticsLogger logger) { if (member.Name == nameof(string.Length) - && instance?.Type == typeof(string)) + && member.DeclaringType == typeof(string)) { return _sqlExpressionFactory.NullableFunction( "CHAR_LENGTH", diff --git a/src/EFCore.MySql/Query/Internal/MySqlStringMethodTranslator.cs b/src/EFCore.MySql/Query/Internal/MySqlStringMethodTranslator.cs index acadb066d..827447326 100644 --- a/src/EFCore.MySql/Query/Internal/MySqlStringMethodTranslator.cs +++ b/src/EFCore.MySql/Query/Internal/MySqlStringMethodTranslator.cs @@ -110,6 +110,17 @@ private static readonly MethodInfo _removeMethodInfoWithTwoArgs p.ParameterType.GetGenericTypeDefinition() == typeof(IEnumerable<>)))) .ToArray(); + private static readonly MethodInfo[] _joinMethodInfos = typeof(string).GetRuntimeMethods() + .Where( + m => m is { Name: nameof(string.Join) } && + m.GetParameters() is { Length: 2 } parameters && + (parameters[0].ParameterType == typeof(string) || + parameters[0].ParameterType == typeof(char)) && + (parameters[1].ParameterType == typeof(string[]) || + parameters[1].ParameterType == typeof(object[]) || + parameters[1].ParameterType == typeof(IEnumerable<>))) + .ToArray(); + private readonly MySqlSqlExpressionFactory _sqlExpressionFactory; public MySqlStringMethodTranslator( @@ -169,7 +180,7 @@ public override SqlExpression Translate( _sqlExpressionFactory.IsNotNull(replacementArgument), replaceCall) }, - _sqlExpressionFactory.Constant(null, RelationalTypeMapping.NullMapping)); + _sqlExpressionFactory.Constant(null, replaceCall.Type, replaceCall.TypeMapping)); } if (_toLowerMethodInfo.Equals(method) @@ -431,6 +442,54 @@ public override SqlExpression Translate( onlyNullWhenAnyNullPropagatingArgumentIsNull: arguments[0] is not MySqlComplexFunctionArgumentExpression); } + if (_joinMethodInfos.Contains( + (method.IsGenericMethod + ? method.GetGenericMethodDefinition() + : null) ?? method)) + { + // Handle + // char, object[] + // char, string[] + // char, IEnumerable + // string, object[] + // string, string[] + // string, IEnumerable + // string, IEnumerable + // + // Some call signature variants can never reach this code, because they will be directly called and thus only their result + // is translated. + var concatWsArguments = arguments[1] is MySqlComplexFunctionArgumentExpression mySqlComplexFunctionArgumentExpression + ? [ + arguments[0], + // CONCAT_WS filters out nulls, but string.Join treats them as empty strings; so coalesce (which is a no-op for + // non-nullable arguments). + mySqlComplexFunctionArgumentExpression.Update( + mySqlComplexFunctionArgumentExpression.ArgumentParts + .Select(e => _sqlExpressionFactory.Coalesce(e, _sqlExpressionFactory.Constant(string.Empty))) + .ToList(), + mySqlComplexFunctionArgumentExpression.Delimiter)] + : arguments.Select( + e => e switch + { + SqlConstantExpression c => _sqlExpressionFactory.Constant(c.Value.ToString()), + SqlParameterExpression p => p.ApplyTypeMapping( + ((MySqlStringTypeMapping)_typeMappingSource.GetMapping(typeof(string))).Clone(forceToString: true)), + _ => e, + }) + .Prepend(arguments[0]) + .ToArray(); + + // We haven't implemented expansion of MySqlComplexFunctionArgumentExpression yet, so the default nullability check would + // result in an invalid SQL generation. + // TODO: Fix at some point. + return _sqlExpressionFactory.NullableFunction( + "CONCAT_WS", + concatWsArguments, + method.ReturnType, + onlyNullWhenAnyNullPropagatingArgumentIsNull: arguments[0] is not MySqlComplexFunctionArgumentExpression, + argumentsPropagateNullability: [true, false]); + } + return null; } diff --git a/src/EFCore.MySql/Query/Internal/SkipTakeCollapsingExpressionVisitor.cs b/src/EFCore.MySql/Query/Internal/SkipTakeCollapsingExpressionVisitor.cs index 217c83d53..4ec971bb3 100644 --- a/src/EFCore.MySql/Query/Internal/SkipTakeCollapsingExpressionVisitor.cs +++ b/src/EFCore.MySql/Query/Internal/SkipTakeCollapsingExpressionVisitor.cs @@ -52,7 +52,6 @@ protected override Expression VisitExtension(Expression extensionExpression) && IsZero(selectExpression.Offset)) { return selectExpression.Update( - selectExpression.Projection, selectExpression.Tables, selectExpression.GroupBy.Count > 0 ? selectExpression.Predicate @@ -61,9 +60,10 @@ protected override Expression VisitExtension(Expression extensionExpression) selectExpression.GroupBy.Count > 0 ? _sqlExpressionFactory.ApplyDefaultTypeMapping(_sqlExpressionFactory.Constant(false)) : null, + selectExpression.Projection, new List(0), - limit: null, - offset: null); + offset: null, + limit: null); } bool IsZero(SqlExpression? sqlExpression) diff --git a/src/EFCore.MySql/Scaffolding/Internal/MySqlDatabaseModelFactory.cs b/src/EFCore.MySql/Scaffolding/Internal/MySqlDatabaseModelFactory.cs index dbcfe7883..ca8807180 100644 --- a/src/EFCore.MySql/Scaffolding/Internal/MySqlDatabaseModelFactory.cs +++ b/src/EFCore.MySql/Scaffolding/Internal/MySqlDatabaseModelFactory.cs @@ -208,7 +208,7 @@ private static Func GenerateSchemaFilter(IReadOnlyList s FROM `INFORMATION_SCHEMA`.`TABLES` as `t` LEFT JOIN - `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`COLLATION_NAME` = `t`.`TABLE_COLLATION` + `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`{0}` = `t`.`TABLE_COLLATION` WHERE `TABLE_SCHEMA` = SCHEMA() AND @@ -222,8 +222,12 @@ protected virtual IEnumerable GetTables( { using (var command = connection.CreateCommand()) { + var collationColumnName = _options.ServerVersion.Supports.CollationCharacterSetApplicabilityWithFullCollationNameColumn + ? "FULL_COLLATION_NAME" + : "COLLATION_NAME"; + var tables = new List(); - command.CommandText = GetTablesQuery; + command.CommandText = string.Format(GetTablesQuery, collationColumnName); using (var reader = command.ExecuteReader()) { while (reader.Read()) diff --git a/src/EFCore.MySql/Storage/Internal/Json/MySqlJsonByteArrayAsHexStringReaderWriter.cs b/src/EFCore.MySql/Storage/Internal/Json/MySqlJsonByteArrayAsHexStringReaderWriter.cs index 48631c6c6..eaa7a2238 100644 --- a/src/EFCore.MySql/Storage/Internal/Json/MySqlJsonByteArrayAsHexStringReaderWriter.cs +++ b/src/EFCore.MySql/Storage/Internal/Json/MySqlJsonByteArrayAsHexStringReaderWriter.cs @@ -2,6 +2,8 @@ // Licensed under the MIT. See LICENSE in the project root for license information. using System; +using System.Linq.Expressions; +using System.Reflection; using System.Text.Json; using Microsoft.EntityFrameworkCore.Storage.Json; @@ -9,6 +11,9 @@ namespace Pomelo.EntityFrameworkCore.MySql.Storage.Internal.Json; public sealed class MySqlJsonByteArrayAsHexStringReaderWriter : JsonValueReaderWriter { + public static readonly PropertyInfo InstanceProperty = + typeof(MySqlJsonByteArrayAsHexStringReaderWriter).GetProperty(nameof(Instance)); + public static MySqlJsonByteArrayAsHexStringReaderWriter Instance { get; } = new(); private MySqlJsonByteArrayAsHexStringReaderWriter() @@ -20,4 +25,7 @@ public override byte[] FromJsonTyped(ref Utf8JsonReaderManager manager, object e public override void ToJsonTyped(Utf8JsonWriter writer, byte[] value) => writer.WriteStringValue(Convert.ToHexString(value)); + + public override Expression ConstructorExpression + => Expression.Property(null, InstanceProperty); } diff --git a/test/EFCore.MySql.FunctionalTests/BuiltInDataTypesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BuiltInDataTypesMySqlTest.cs index d8f50e5e9..a7d006a58 100644 --- a/test/EFCore.MySql.FunctionalTests/BuiltInDataTypesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BuiltInDataTypesMySqlTest.cs @@ -5,6 +5,7 @@ using System.Linq; using System.Linq.Expressions; using System.Text; +using System.Threading.Tasks; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; @@ -32,12 +33,12 @@ public BuiltInDataTypesMySqlTest(BuiltInDataTypesMySqlFixture fixture, ITestOutp //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override void Object_to_string_conversion() + public override async Task Object_to_string_conversion() { using var context = CreateContext(); - var expected = context.Set() - .Where(e => e.Id == 13) - .AsEnumerable() + var expected = (await context.Set() + .Where(e => e.Id == 13) + .ToListAsync()) .Select( b => new { @@ -56,7 +57,7 @@ public override void Object_to_string_conversion() Fixture.ListLoggerFactory.Clear(); - var query = context.Set() + var query = await context.Set() .Where(e => e.Id == 13) .Select( b => new @@ -77,7 +78,7 @@ public override void Object_to_string_conversion() DateTimeOffset = b.TestDateTimeOffset.ToString(), TimeSpan = b.TestTimeSpan.ToString() }) - .ToList(); + .ToListAsync(); var actual = Assert.Single(query); Assert.Equal(expected.Sbyte, actual.Sbyte); @@ -875,7 +876,7 @@ public virtual void Can_insert_and_read_back_all_mapped_data_types_set_to_null() // Overridden because of TestNullableDateTimeOffset, since MySQL does not offer a native data type to save a date/time with // timezone. - public override void Can_insert_and_read_back_all_nullable_data_types_with_values_set_to_non_null() + public override async Task Can_insert_and_read_back_all_nullable_data_types_with_values_set_to_non_null() { using (var context = CreateContext()) { @@ -912,12 +913,12 @@ public override void Can_insert_and_read_back_all_nullable_data_types_with_value EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(BuiltInNullableDataTypes)); AssertEqualIfMapped(entityType, "TestString", () => dt.TestString); @@ -1521,7 +1522,7 @@ public void Can_get_column_types_from_built_model() #region https://github.com/dotnet/efcore/issues/26068 [ConditionalFact] - public override void Can_insert_and_read_back_all_non_nullable_data_types() + public override async Task Can_insert_and_read_back_all_non_nullable_data_types() { using (var context = CreateContext()) { @@ -1556,12 +1557,12 @@ public override void Can_insert_and_read_back_all_non_nullable_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(e => e.Id == 1).ToList().Single(); + var dt = (await context.Set().Where(e => e.Id == 1).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(BuiltInDataTypes)); AssertEqualIfMapped(entityType, (short)-1234, () => dt.TestInt16); @@ -1595,7 +1596,7 @@ public override void Can_insert_and_read_back_all_non_nullable_data_types() } [ConditionalFact] - public override void Can_insert_and_read_back_non_nullable_backed_data_types() + public override async Task Can_insert_and_read_back_non_nullable_backed_data_types() { using (var context = CreateContext()) { @@ -1630,12 +1631,12 @@ public override void Can_insert_and_read_back_non_nullable_backed_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(NonNullableBackedDataTypes)); AssertEqualIfMapped(entityType, (short)-1234, () => dt.Int16); @@ -1669,7 +1670,7 @@ public override void Can_insert_and_read_back_non_nullable_backed_data_types() } [ConditionalFact] - public override void Can_insert_and_read_back_nullable_backed_data_types() + public override async Task Can_insert_and_read_back_nullable_backed_data_types() { using (var context = CreateContext()) { @@ -1704,12 +1705,12 @@ public override void Can_insert_and_read_back_nullable_backed_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(NullableBackedDataTypes)); AssertEqualIfMapped(entityType, (short)-1234, () => dt.Int16); @@ -1742,7 +1743,7 @@ public override void Can_insert_and_read_back_nullable_backed_data_types() } [ConditionalFact] - public override void Can_insert_and_read_back_object_backed_data_types() + public override async Task Can_insert_and_read_back_object_backed_data_types() { using (var context = CreateContext()) { @@ -1779,12 +1780,12 @@ public override void Can_insert_and_read_back_object_backed_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(ObjectBackedDataTypes)); AssertEqualIfMapped(entityType, "TestString", () => dt.String); diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/ComplexTypeBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/ComplexTypeBulkUpdatesMySqlTest.cs index f87694622..b399cb473 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/ComplexTypeBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/ComplexTypeBulkUpdatesMySqlTest.cs @@ -7,7 +7,7 @@ namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.BulkUpdates; -public class ComplexTypeBulkUpdatesMySqlTest : ComplexTypeBulkUpdatesTestBase< +public class ComplexTypeBulkUpdatesMySqlTest : ComplexTypeBulkUpdatesRelationalTestBase< ComplexTypeBulkUpdatesMySqlTest.ComplexTypeBulkUpdatesMySqlFixture> { public ComplexTypeBulkUpdatesMySqlTest(ComplexTypeBulkUpdatesMySqlFixture fixture, ITestOutputHelper testOutputHelper) @@ -27,9 +27,9 @@ public override async Task Delete_entity_type_with_complex_type(bool async) """); } - public override async Task Delete_complex_type_throws(bool async) + public override async Task Delete_complex_type(bool async) { - await base.Delete_complex_type_throws(async); + await base.Delete_complex_type(async); AssertSql(); } @@ -95,9 +95,9 @@ public override async Task Update_multiple_projected_complex_types_via_anonymous """); } - public override async Task Update_projected_complex_type_via_OrderBy_Skip_throws(bool async) + public override async Task Update_projected_complex_type_via_OrderBy_Skip(bool async) { - await base.Update_projected_complex_type_via_OrderBy_Skip_throws(async); + await base.Update_projected_complex_type_via_OrderBy_Skip(async); AssertExecuteUpdateSql(); } @@ -304,7 +304,7 @@ public override async Task Update_collection_inside_complex_type(bool async) [ConditionalFact] public virtual void Check_all_tests_overridden() { - TestHelpers.AssertAllMethodsOverridden(GetType()); + MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); } private void AssertExecuteUpdateSql(params string[] expected) @@ -322,7 +322,7 @@ protected void ClearLog() Fixture.TestSqlLoggerFactory.Clear(); } - public class ComplexTypeBulkUpdatesMySqlFixture : ComplexTypeBulkUpdatesFixtureBase + public class ComplexTypeBulkUpdatesMySqlFixture : ComplexTypeBulkUpdatesRelationalFixtureBase { protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NonSharedModelBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NonSharedModelBulkUpdatesMySqlTest.cs index 81c2441cd..d11cd5bf4 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NonSharedModelBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NonSharedModelBulkUpdatesMySqlTest.cs @@ -7,14 +7,14 @@ namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.BulkUpdates; -public class NonSharedModelBulkUpdatesMySqlTest : NonSharedModelBulkUpdatesTestBase +public class NonSharedModelBulkUpdatesMySqlTest : NonSharedModelBulkUpdatesRelationalTestBase { protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Delete_aggregate_root_when_eager_loaded_owned_collection(bool async) { @@ -88,7 +88,7 @@ public override async Task Update_owned_and_non_owned_properties_with_table_shar """ UPDATE `Owner` AS `o` SET `o`.`OwnedReference_Number` = CHAR_LENGTH(`o`.`Title`), - `o`.`Title` = CAST(`o`.`OwnedReference_Number` AS char) + `o`.`Title` = COALESCE(CAST(`o`.`OwnedReference_Number` AS char), '') """); } @@ -158,6 +158,18 @@ public override async Task Update_non_owned_property_on_entity_with_owned_in_joi """); } + public override async Task Replace_ColumnExpression_in_column_setter(bool async) + { + await base.Replace_ColumnExpression_in_column_setter(async); + + AssertSql( +""" +UPDATE `Owner` AS `o` +INNER JOIN `OwnedCollection` AS `o0` ON `o`.`Id` = `o0`.`OwnerId` +SET `o0`.`Value` = 'SomeValue' +"""); + } + private void AssertSql(params string[] expected) => TestSqlLoggerFactory.AssertBaseline(expected); diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlFixture.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlFixture.cs index 5b78b4580..623ef770a 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlFixture.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlFixture.cs @@ -7,8 +7,8 @@ namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.BulkUpdates; -public class NorthwindBulkUpdatesMySqlFixture : NorthwindBulkUpdatesFixture - where TModelCustomizer : IModelCustomizer, new() +public class NorthwindBulkUpdatesMySqlFixture : NorthwindBulkUpdatesRelationalFixture + where TModelCustomizer : ITestModelCustomizer, new() { protected override ITestStoreFactory TestStoreFactory => MySqlNorthwindTestStoreFactory.Instance; diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlTest.cs index d00896714..6dbd2725f 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/NorthwindBulkUpdatesMySqlTest.cs @@ -4,6 +4,7 @@ using Microsoft.EntityFrameworkCore.TestModels.Northwind; using Microsoft.EntityFrameworkCore.TestUtilities; using MySqlConnector; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.Infrastructure; using Pomelo.EntityFrameworkCore.MySql.Tests; using Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes; @@ -12,7 +13,7 @@ namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.BulkUpdates; -public class NorthwindBulkUpdatesMySqlTest : NorthwindBulkUpdatesTestBase> +public class NorthwindBulkUpdatesMySqlTest : NorthwindBulkUpdatesRelationalTestBase> { public NorthwindBulkUpdatesMySqlTest( NorthwindBulkUpdatesMySqlFixture fixture, @@ -25,7 +26,7 @@ public NorthwindBulkUpdatesMySqlTest( [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Delete_Where_TagWith(bool async) { @@ -1387,12 +1388,12 @@ public override async Task Update_Where_Join_set_property_from_joined_single_res AssertExecuteUpdateSql( """ UPDATE `Customers` AS `c` -SET `c`.`City` = CAST(EXTRACT(year FROM ( +SET `c`.`City` = COALESCE(CAST(EXTRACT(year FROM ( SELECT `o`.`OrderDate` FROM `Orders` AS `o` WHERE `c`.`CustomerID` = `o`.`CustomerID` ORDER BY `o`.`OrderDate` DESC - LIMIT 1)) AS char) + LIMIT 1)) AS char), '') WHERE `c`.`CustomerID` LIKE 'F%' """); } @@ -1421,12 +1422,12 @@ public override async Task Update_Where_Join_set_property_from_joined_single_res AssertExecuteUpdateSql( """ UPDATE `Customers` AS `c` -SET `c`.`City` = CAST(EXTRACT(year FROM ( +SET `c`.`City` = COALESCE(CAST(EXTRACT(year FROM ( SELECT `o`.`OrderDate` FROM `Orders` AS `o` WHERE `c`.`CustomerID` = `o`.`CustomerID` ORDER BY `o`.`OrderDate` DESC - LIMIT 1)) AS char) + LIMIT 1)) AS char), '') WHERE `c`.`CustomerID` LIKE 'F%' """); } diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPCFiltersInheritanceBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPCFiltersInheritanceBulkUpdatesMySqlTest.cs index 2a7aab5d6..656a32ce5 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPCFiltersInheritanceBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPCFiltersInheritanceBulkUpdatesMySqlTest.cs @@ -1,6 +1,7 @@ using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.BulkUpdates; using Microsoft.EntityFrameworkCore.TestUtilities; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Xunit; using Xunit.Abstractions; @@ -19,7 +20,7 @@ public TPCFiltersInheritanceBulkUpdatesMySqlTest( [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Delete_where_hierarchy(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPCInheritanceBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPCInheritanceBulkUpdatesMySqlTest.cs index 40d0bf351..8ea90d35c 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPCInheritanceBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPCInheritanceBulkUpdatesMySqlTest.cs @@ -1,6 +1,7 @@ using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.BulkUpdates; using Microsoft.EntityFrameworkCore.TestUtilities; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Xunit; using Xunit.Abstractions; @@ -18,7 +19,7 @@ public TPCInheritanceBulkUpdatesMySqlTest( [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Delete_where_hierarchy(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPHFiltersInheritanceBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPHFiltersInheritanceBulkUpdatesMySqlTest.cs index 5865e1469..9fb819758 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPHFiltersInheritanceBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPHFiltersInheritanceBulkUpdatesMySqlTest.cs @@ -1,9 +1,9 @@ using System; using System.Threading.Tasks; -using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.BulkUpdates; using Microsoft.EntityFrameworkCore.TestUtilities; using MySqlConnector; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.Infrastructure; using Pomelo.EntityFrameworkCore.MySql.Tests; using Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes; @@ -22,7 +22,7 @@ public TPHFiltersInheritanceBulkUpdatesMySqlTest(TPHFiltersInheritanceBulkUpdate [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Delete_where_hierarchy(bool async) { @@ -162,13 +162,6 @@ SELECT COUNT(*) """); } - public override async Task Update_where_keyless_entity_mapped_to_sql_query(bool async) - { - await base.Update_where_keyless_entity_mapped_to_sql_query(async); - - AssertExecuteUpdateSql(); - } - public override async Task Update_base_type(bool async) { await base.Update_base_type(async); @@ -238,19 +231,12 @@ public override async Task Delete_where_hierarchy_subquery(bool async) AssertSql(); } - public override async Task Delete_where_keyless_entity_mapped_to_sql_query(bool async) - { - await base.Delete_where_keyless_entity_mapped_to_sql_query(async); - - AssertSql(); - } - - protected override void ClearLog() - => Fixture.TestSqlLoggerFactory.Clear(); - private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); private void AssertExecuteUpdateSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected, forUpdate: true); + + private void ClearLog() + => Fixture.TestSqlLoggerFactory.Clear(); } diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPHInheritanceBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPHInheritanceBulkUpdatesMySqlTest.cs index 133b2bab8..47723adc7 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPHInheritanceBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPHInheritanceBulkUpdatesMySqlTest.cs @@ -2,23 +2,27 @@ using Microsoft.EntityFrameworkCore.BulkUpdates; using Microsoft.EntityFrameworkCore.TestUtilities; using MySqlConnector; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.Infrastructure; using Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes; using Xunit; +using Xunit.Abstractions; namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.BulkUpdates; public class TPHInheritanceBulkUpdatesMySqlTest : TPHInheritanceBulkUpdatesTestBase { - public TPHInheritanceBulkUpdatesMySqlTest(TPHInheritanceBulkUpdatesMySqlFixture fixture) - : base(fixture) + public TPHInheritanceBulkUpdatesMySqlTest( + TPHInheritanceBulkUpdatesMySqlFixture fixture, + ITestOutputHelper testOutputHelper) + : base(fixture, testOutputHelper) { ClearLog(); } [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Delete_where_hierarchy(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPTFiltersInheritanceBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPTFiltersInheritanceBulkUpdatesMySqlTest.cs index 5c3f4220f..519dfcd30 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPTFiltersInheritanceBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPTFiltersInheritanceBulkUpdatesMySqlTest.cs @@ -1,6 +1,7 @@ using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.BulkUpdates; using Microsoft.EntityFrameworkCore.TestUtilities; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Xunit; using Xunit.Abstractions; @@ -19,7 +20,7 @@ public TPTFiltersInheritanceBulkUpdatesMySqlTest( [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Delete_where_hierarchy(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPTInheritanceBulkUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPTInheritanceBulkUpdatesMySqlTest.cs index 37e1f31c1..77bcc946d 100644 --- a/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPTInheritanceBulkUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/BulkUpdates/TPTInheritanceBulkUpdatesMySqlTest.cs @@ -1,6 +1,7 @@ using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.BulkUpdates; using Microsoft.EntityFrameworkCore.TestUtilities; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Xunit; using Xunit.Abstractions; @@ -18,7 +19,7 @@ public TPTInheritanceBulkUpdatesMySqlTest( [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Delete_where_hierarchy(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/ConnectionMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/ConnectionMySqlTest.cs index 0b2238ba1..38badf3b3 100644 --- a/test/EFCore.MySql.FunctionalTests/ConnectionMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/ConnectionMySqlTest.cs @@ -1,4 +1,6 @@ using System; +using System.Threading; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Storage; @@ -53,65 +55,65 @@ public virtual void SetConnectionString_affects_master_connection() } [Fact] - public void Can_create_admin_connection_with_data_source() + public async Task Can_create_admin_connection_with_data_source() { - using var _ = ((MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance + await using var _ = await ((MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance .GetOrCreate("ConnectionTest")) - .Initialize(null, (Func)null); + .InitializeAsync(null, (Func)null); - using var dataSource = new MySqlDataSourceBuilder(MySqlTestStore.CreateConnectionString("ConnectionTest")).Build(); + await using var dataSource = new MySqlDataSourceBuilder(MySqlTestStore.CreateConnectionString("ConnectionTest")).Build(); var optionsBuilder = new DbContextOptionsBuilder(); optionsBuilder.UseMySql(dataSource, AppConfig.ServerVersion, b => b.ApplyConfiguration()); - using var context = new GeneralOptionsContext(optionsBuilder.Options); + await using var context = new GeneralOptionsContext(optionsBuilder.Options); var relationalConnection = context.GetService(); - using var masterConnection = relationalConnection.CreateMasterConnection(); + await using var masterConnection = relationalConnection.CreateMasterConnection(); Assert.Equal(string.Empty, new MySqlConnectionStringBuilder(masterConnection.ConnectionString).Database); - masterConnection.Open(); + await masterConnection.OpenAsync(default); } [Fact] - public void Can_create_admin_connection_with_connection_string() + public async Task Can_create_admin_connection_with_connection_string() { - using var _ = ((MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance + await using var _ = await ((MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance .GetOrCreate("ConnectionTest")) - .Initialize(null, (Func)null); + .InitializeAsync(null, (Func)null); var optionsBuilder = new DbContextOptionsBuilder(); optionsBuilder.UseMySql(MySqlTestStore.CreateConnectionString("ConnectionTest"), AppConfig.ServerVersion, b => b.ApplyConfiguration()); - using var context = new GeneralOptionsContext(optionsBuilder.Options); + await using var context = new GeneralOptionsContext(optionsBuilder.Options); var relationalConnection = context.GetService(); - using var masterConnection = relationalConnection.CreateMasterConnection(); + await using var masterConnection = relationalConnection.CreateMasterConnection(); Assert.Equal(string.Empty, new MySqlConnectionStringBuilder(masterConnection.ConnectionString).Database); - masterConnection.Open(); + await masterConnection.OpenAsync(default); } [Fact] - public void Can_create_admin_connection_with_connection() + public async Task Can_create_admin_connection_with_connection() { - using var _ = ((MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance + await using var _ = await ((MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance .GetOrCreate("ConnectionTest")) - .Initialize(null, (Func)null); + .InitializeAsync(null, (Func)null); - using var connection = new MySqlConnection(MySqlTestStore.CreateConnectionString("ConnectionTest")); + await using var connection = new MySqlConnection(MySqlTestStore.CreateConnectionString("ConnectionTest")); connection.Open(); var optionsBuilder = new DbContextOptionsBuilder(); optionsBuilder.UseMySql(connection, AppConfig.ServerVersion, b => b.ApplyConfiguration()); - using var context = new GeneralOptionsContext(optionsBuilder.Options); + await using var context = new GeneralOptionsContext(optionsBuilder.Options); var relationalConnection = context.GetService(); - using var masterConnection = relationalConnection.CreateMasterConnection(); + await using var masterConnection = relationalConnection.CreateMasterConnection(); Assert.Equal(string.Empty, new MySqlConnectionStringBuilder(masterConnection.ConnectionString).Database); - masterConnection.Open(); + await masterConnection.OpenAsync(default); } [Fact] diff --git a/test/EFCore.MySql.FunctionalTests/ConvertToProviderTypesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/ConvertToProviderTypesMySqlTest.cs index 2b6399ed7..5cecfec35 100644 --- a/test/EFCore.MySql.FunctionalTests/ConvertToProviderTypesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/ConvertToProviderTypesMySqlTest.cs @@ -2,6 +2,7 @@ using System.Globalization; using System.Linq; using System.Linq.Expressions; +using System.Threading.Tasks; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Diagnostics; @@ -23,8 +24,9 @@ public ConvertToProviderTypesMySqlTest(ConvertToProviderTypesMySqlFixture fixtur //fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override void Can_perform_query_with_ansi_strings_test() + public override Task Can_perform_query_with_ansi_strings_test() { + return Task.CompletedTask; } // TODO: Needed to customize: @@ -33,7 +35,7 @@ public override void Can_perform_query_with_ansi_strings_test() #region https://github.com/dotnet/efcore/issues/26068 [ConditionalFact] - public override void Can_insert_and_read_back_all_non_nullable_data_types() + public override async Task Can_insert_and_read_back_all_non_nullable_data_types() { using (var context = CreateContext()) { @@ -68,12 +70,12 @@ public override void Can_insert_and_read_back_all_non_nullable_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(e => e.Id == 1).ToList().Single(); + var dt = (await context.Set().Where(e => e.Id == 1).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(BuiltInDataTypes)); AssertEqualIfMapped(entityType, (short)-1234, () => dt.TestInt16); @@ -107,7 +109,7 @@ public override void Can_insert_and_read_back_all_non_nullable_data_types() } [ConditionalFact] - public override void Can_insert_and_read_back_non_nullable_backed_data_types() + public override async Task Can_insert_and_read_back_non_nullable_backed_data_types() { using (var context = CreateContext()) { @@ -142,12 +144,12 @@ public override void Can_insert_and_read_back_non_nullable_backed_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(NonNullableBackedDataTypes)); AssertEqualIfMapped(entityType, (short)-1234, () => dt.Int16); @@ -181,7 +183,7 @@ public override void Can_insert_and_read_back_non_nullable_backed_data_types() } [ConditionalFact] - public override void Can_insert_and_read_back_nullable_backed_data_types() + public override async Task Can_insert_and_read_back_nullable_backed_data_types() { using (var context = CreateContext()) { @@ -216,12 +218,12 @@ public override void Can_insert_and_read_back_nullable_backed_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(NullableBackedDataTypes)); AssertEqualIfMapped(entityType, (short)-1234, () => dt.Int16); @@ -254,7 +256,7 @@ public override void Can_insert_and_read_back_nullable_backed_data_types() } [ConditionalFact] - public override void Can_insert_and_read_back_object_backed_data_types() + public override async Task Can_insert_and_read_back_object_backed_data_types() { using (var context = CreateContext()) { @@ -291,12 +293,12 @@ public override void Can_insert_and_read_back_object_backed_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(ObjectBackedDataTypes)); AssertEqualIfMapped(entityType, "TestString", () => dt.String); diff --git a/test/EFCore.MySql.FunctionalTests/CustomConvertersMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/CustomConvertersMySqlTest.cs index e24a71e29..fa80aacb0 100644 --- a/test/EFCore.MySql.FunctionalTests/CustomConvertersMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/CustomConvertersMySqlTest.cs @@ -2,6 +2,7 @@ using System.Globalization; using System.Linq; using System.Linq.Expressions; +using System.Threading.Tasks; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; @@ -32,7 +33,7 @@ public override void Value_conversion_on_enum_collection_contains() #region https://github.com/dotnet/efcore/issues/26068 [ConditionalFact] - public override void Can_insert_and_read_back_all_non_nullable_data_types() + public override async Task Can_insert_and_read_back_all_non_nullable_data_types() { using (var context = CreateContext()) { @@ -67,12 +68,12 @@ public override void Can_insert_and_read_back_all_non_nullable_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(e => e.Id == 1).ToList().Single(); + var dt = (await context.Set().Where(e => e.Id == 1).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(BuiltInDataTypes)); AssertEqualIfMapped(entityType, (short)-1234, () => dt.TestInt16); @@ -106,7 +107,7 @@ public override void Can_insert_and_read_back_all_non_nullable_data_types() } [ConditionalFact] - public override void Can_insert_and_read_back_non_nullable_backed_data_types() + public override async Task Can_insert_and_read_back_non_nullable_backed_data_types() { using (var context = CreateContext()) { @@ -141,12 +142,12 @@ public override void Can_insert_and_read_back_non_nullable_backed_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(NonNullableBackedDataTypes)); AssertEqualIfMapped(entityType, (short)-1234, () => dt.Int16); @@ -180,7 +181,7 @@ public override void Can_insert_and_read_back_non_nullable_backed_data_types() } [ConditionalFact] - public override void Can_insert_and_read_back_nullable_backed_data_types() + public override async Task Can_insert_and_read_back_nullable_backed_data_types() { using (var context = CreateContext()) { @@ -215,12 +216,12 @@ public override void Can_insert_and_read_back_nullable_backed_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(NullableBackedDataTypes)); AssertEqualIfMapped(entityType, (short)-1234, () => dt.Int16); @@ -253,7 +254,7 @@ public override void Can_insert_and_read_back_nullable_backed_data_types() } [ConditionalFact] - public override void Can_insert_and_read_back_object_backed_data_types() + public override async Task Can_insert_and_read_back_object_backed_data_types() { using (var context = CreateContext()) { @@ -290,12 +291,12 @@ public override void Can_insert_and_read_back_object_backed_data_types() EnumS8 = EnumS8.SomeValue }); - Assert.Equal(1, context.SaveChanges()); + Assert.Equal(1, await context.SaveChangesAsync()); } using (var context = CreateContext()) { - var dt = context.Set().Where(ndt => ndt.Id == 101).ToList().Single(); + var dt = (await context.Set().Where(ndt => ndt.Id == 101).ToListAsync()).Single(); var entityType = context.Model.FindEntityType(typeof(ObjectBackedDataTypes)); AssertEqualIfMapped(entityType, "TestString", () => dt.String); diff --git a/test/EFCore.MySql.FunctionalTests/DataAnnotationMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/DataAnnotationMySqlTest.cs index 30bf92ff5..3c5942cc8 100644 --- a/test/EFCore.MySql.FunctionalTests/DataAnnotationMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/DataAnnotationMySqlTest.cs @@ -1,3 +1,4 @@ +using System.Threading.Tasks; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; @@ -109,9 +110,9 @@ public override IModel TableNameAttribute_affects_table_name_in_TPH() return model; } - public override void ConcurrencyCheckAttribute_throws_if_value_in_database_changed() + public override async Task ConcurrencyCheckAttribute_throws_if_value_in_database_changed() { - base.ConcurrencyCheckAttribute_throws_if_value_in_database_changed(); + await base.ConcurrencyCheckAttribute_throws_if_value_in_database_changed(); AssertSql( """ @@ -153,9 +154,9 @@ LIMIT 1 """); } - public override void DatabaseGeneratedAttribute_autogenerates_values_when_set_to_identity() + public override async Task DatabaseGeneratedAttribute_autogenerates_values_when_set_to_identity() { - base.DatabaseGeneratedAttribute_autogenerates_values_when_set_to_identity(); + await base.DatabaseGeneratedAttribute_autogenerates_values_when_set_to_identity(); if (AppConfig.ServerVersion.Supports.Returning) { diff --git a/test/EFCore.MySql.FunctionalTests/EFCore.MySql.FunctionalTests.csproj b/test/EFCore.MySql.FunctionalTests/EFCore.MySql.FunctionalTests.csproj index 668dae678..c5295a16f 100644 --- a/test/EFCore.MySql.FunctionalTests/EFCore.MySql.FunctionalTests.csproj +++ b/test/EFCore.MySql.FunctionalTests/EFCore.MySql.FunctionalTests.csproj @@ -7,7 +7,7 @@ true $(DefaultItemExcludes);*.trx - + false false @@ -29,10 +29,6 @@ - - - - @@ -75,11 +71,17 @@ $(LocalEFCoreRepository)\artifacts\bin\EFCore.Design.Tests\Debug\$(EfCoreTestTargetFramework)\Microsoft.EntityFrameworkCore.Design.dll + + + + + + + - - + diff --git a/test/EFCore.MySql.FunctionalTests/ExistingConnectionMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/ExistingConnectionMySqlTest.cs index 2e83de1d5..297496bfc 100644 --- a/test/EFCore.MySql.FunctionalTests/ExistingConnectionMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/ExistingConnectionMySqlTest.cs @@ -23,16 +23,16 @@ private static async Task Can_use_an_existing_closed_connection(bool openConnect .AddEntityFrameworkMySql() .BuildServiceProvider(); - using (var store = (MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance - .GetOrCreate(null) - .Initialize(null, (Func)null)) + await using (var store = (MySqlTestStore)await MySqlNorthwindTestStoreFactory.Instance + .GetOrCreate(null) + .InitializeAsync(null, (Func)null)) { store.CloseConnection(); var openCount = 0; var closeCount = 0; - using (var connection = new MySqlConnection(store.ConnectionString)) + await using (var connection = new MySqlConnection(store.ConnectionString)) { if (openConnection) { @@ -56,7 +56,7 @@ private static async Task Can_use_an_existing_closed_connection(bool openConnect .UseInternalServiceProvider(serviceProvider) .Options; - using (var context = new NorthwindContext(options)) + await using (var context = new NorthwindContext(options)) { Assert.Equal(91, await context.Customers.CountAsync()); } @@ -84,9 +84,9 @@ private static async Task Closed_connection_missing_AllowUserVariables_true_in_o .AddEntityFrameworkMySql() .BuildServiceProvider(); - await using (var store = (MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance + await using (var store = (MySqlTestStore)await MySqlNorthwindTestStoreFactory.Instance .GetOrCreate(null) - .Initialize(null, (Func)null)) + .InitializeAsync(null, (Func)null)) { store.CloseConnection(); @@ -99,7 +99,7 @@ private static async Task Closed_connection_missing_AllowUserVariables_true_in_o .UseInternalServiceProvider(serviceProvider) .Options; - using var context = new NorthwindContext(options); + await using var context = new NorthwindContext(options); Assert.Equal(91, await context.Customers.CountAsync()); } @@ -109,9 +109,9 @@ private static async Task Closed_connection_missing_AllowUserVariables_true_in_o [Fact] private static async Task Opened_connection_missing_AllowUserVariables_true_in_original_connection_string_throws() { - await using (var store = (MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance + await using (var store = (MySqlTestStore)await MySqlNorthwindTestStoreFactory.Instance .GetOrCreate(null) - .Initialize(null, (Func)null)) + .InitializeAsync(null, (Func)null)) { store.CloseConnection(); @@ -145,9 +145,9 @@ private static async Task Closed_connection_missing_UseAffectedRows_false_in_ori .AddEntityFrameworkMySql() .BuildServiceProvider(); - await using (var store = (MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance + await using (var store = (MySqlTestStore)await MySqlNorthwindTestStoreFactory.Instance .GetOrCreate(null) - .Initialize(null, (Func)null)) + .InitializeAsync(null, (Func)null)) { store.CloseConnection(); @@ -160,7 +160,7 @@ private static async Task Closed_connection_missing_UseAffectedRows_false_in_ori .UseInternalServiceProvider(serviceProvider) .Options; - using var context = new NorthwindContext(options); + await using var context = new NorthwindContext(options); Assert.Equal(91, await context.Customers.CountAsync()); } @@ -170,9 +170,9 @@ private static async Task Closed_connection_missing_UseAffectedRows_false_in_ori [Fact] private static async Task Opened_connection_missing_UseAffectedRows_false_in_original_connection_string_throws() { - await using (var store = (MySqlTestStore)MySqlNorthwindTestStoreFactory.Instance + await using (var store = (MySqlTestStore)await MySqlNorthwindTestStoreFactory.Instance .GetOrCreate(null) - .Initialize(null, (Func)null)) + .InitializeAsync(null, (Func)null)) { store.CloseConnection(); diff --git a/test/EFCore.MySql.FunctionalTests/FullMigrationsMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/FullMigrationsMySqlTest.cs index 4fa81e43c..977dae823 100644 --- a/test/EFCore.MySql.FunctionalTests/FullMigrationsMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/FullMigrationsMySqlTest.cs @@ -48,15 +48,17 @@ public virtual void Can_create_stored_procedure_script_without_custom_delimiter_ fromMigration: Migration.InitialDatabase, toMigration: "00000000000002_MigrationPrimaryKeyChange2")); + // TODO: 9.0 + // Pomelo helper stored procedure statements should be inside the transaction scope. Assert.Equal( - @"CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( +""" +CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( `MigrationId` varchar(150) CHARACTER SET utf8mb4 NOT NULL, `ProductVersion` varchar(32) CHARACTER SET utf8mb4 NOT NULL, CONSTRAINT `PK___EFMigrationsHistory` PRIMARY KEY (`MigrationId`) ) CHARACTER SET=utf8mb4; START TRANSACTION; - CREATE TABLE `Table1` ( `Id` int NOT NULL, `AlternatePK` int NOT NULL, @@ -66,10 +68,6 @@ public virtual void Can_create_stored_procedure_script_without_custom_delimiter_ INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) VALUES ('00000000000001_MigrationPrimaryKeyChange1', '7.0.0-test'); -COMMIT; - -START TRANSACTION; - DROP PROCEDURE IF EXISTS `POMELO_BEFORE_DROP_PRIMARY_KEY`; CREATE PROCEDURE `POMELO_BEFORE_DROP_PRIMARY_KEY`(IN `SCHEMA_NAME_ARGUMENT` VARCHAR(255), IN `TABLE_NAME_ARGUMENT` VARCHAR(255)) BEGIN @@ -159,7 +157,8 @@ INTO PRIMARY_KEY_COLUMN_NAME DROP PROCEDURE `POMELO_AFTER_ADD_PRIMARY_KEY`; COMMIT; -", + +""", Sql, ignoreLineEndingDifferences: true); } @@ -188,7 +187,8 @@ public virtual void Can_generate_idempotent_up_scripts_with_primary_key_related_ h => Assert.Equal("00000000000002_MigrationPrimaryKeyChange2", h.MigrationId)); Assert.Equal( - @"DROP PROCEDURE IF EXISTS `POMELO_BEFORE_DROP_PRIMARY_KEY`; +""" +DROP PROCEDURE IF EXISTS `POMELO_BEFORE_DROP_PRIMARY_KEY`; DELIMITER // CREATE PROCEDURE `POMELO_BEFORE_DROP_PRIMARY_KEY`(IN `SCHEMA_NAME_ARGUMENT` VARCHAR(255), IN `TABLE_NAME_ARGUMENT` VARCHAR(255)) BEGIN @@ -277,7 +277,6 @@ INTO PRIMARY_KEY_COLUMN_NAME ) CHARACTER SET=utf8mb4; START TRANSACTION; - DROP PROCEDURE IF EXISTS MigrationsScript; DELIMITER // CREATE PROCEDURE MigrationsScript() @@ -311,10 +310,6 @@ IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000 CALL MigrationsScript(); DROP PROCEDURE MigrationsScript; -COMMIT; - -START TRANSACTION; - DROP PROCEDURE IF EXISTS MigrationsScript; DELIMITER // CREATE PROCEDURE MigrationsScript() @@ -366,7 +361,8 @@ IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000 DROP PROCEDURE `POMELO_AFTER_ADD_PRIMARY_KEY`; -", + +""", Sql, ignoreLineEndingDifferences: true); } @@ -394,14 +390,14 @@ public virtual void Drop_primary_key_with_recreating_foreign_keys() h => Assert.Equal("00000000000002_MigrationDropPrimaryKeyWithRecreatingForeignKeys2", h.MigrationId)); Assert.Equal( - @"CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( +""" +CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( `MigrationId` varchar(150) CHARACTER SET utf8mb4 NOT NULL, `ProductVersion` varchar(32) CHARACTER SET utf8mb4 NOT NULL, CONSTRAINT `PK___EFMigrationsHistory` PRIMARY KEY (`MigrationId`) ) CHARACTER SET=utf8mb4; START TRANSACTION; - CREATE TABLE `Foo` ( `FooId` int NOT NULL, CONSTRAINT `PK_Foo` PRIMARY KEY (`FooId`) @@ -423,10 +419,6 @@ public virtual void Drop_primary_key_with_recreating_foreign_keys() INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) VALUES ('00000000000001_MigrationDropPrimaryKeyWithRecreatingForeignKeys1', '7.0.0-test'); -COMMIT; - -START TRANSACTION; - DROP PROCEDURE IF EXISTS `POMELO_BEFORE_DROP_PRIMARY_KEY`; DELIMITER // CREATE PROCEDURE `POMELO_BEFORE_DROP_PRIMARY_KEY`(IN `SCHEMA_NAME_ARGUMENT` VARCHAR(255), IN `TABLE_NAME_ARGUMENT` VARCHAR(255)) @@ -533,7 +525,8 @@ INTO PRIMARY_KEY_COLUMN_NAME COMMIT; -", + +""", Sql, ignoreLineEndingDifferences: true); } diff --git a/test/EFCore.MySql.FunctionalTests/GraphUpdatesMySqlTestBase.cs b/test/EFCore.MySql.FunctionalTests/GraphUpdatesMySqlTestBase.cs index e84d4f7eb..1cd0aa7d5 100644 --- a/test/EFCore.MySql.FunctionalTests/GraphUpdatesMySqlTestBase.cs +++ b/test/EFCore.MySql.FunctionalTests/GraphUpdatesMySqlTestBase.cs @@ -63,6 +63,24 @@ protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext con modelBuilder.Entity().Property("CategoryId").HasDefaultValue(1); modelBuilder.Entity().Property(e => e.CategoryId).HasDefaultValue(2); + + modelBuilder.Entity>( + b => + { + b.Property(e => e.PrimaryGroup).HasDefaultValue(1).HasSentinel(1); + }); + + modelBuilder.Entity>( + b => + { + b.Property(e => e.PrimaryGroup).HasDefaultValue(true); + }); + + modelBuilder.Entity>( + b => + { + b.Property(e => e.PrimaryGroup).HasDefaultValue(true); + }); } } } diff --git a/test/EFCore.MySql.FunctionalTests/ManyToManyLoadMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/ManyToManyLoadMySqlTest.cs index b5a68412c..f6f3e2158 100644 --- a/test/EFCore.MySql.FunctionalTests/ManyToManyLoadMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/ManyToManyLoadMySqlTest.cs @@ -13,7 +13,7 @@ public ManyToManyLoadMySqlTest(ManyToManyLoadMySqlFixture fixture) { } - public class ManyToManyLoadMySqlFixture : ManyToManyLoadFixtureBase + public class ManyToManyLoadMySqlFixture : ManyToManyLoadFixtureBase, ITestSqlLoggerFactory { public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; diff --git a/test/EFCore.MySql.FunctionalTests/ManyToManyTrackingMySqlTestBase.cs b/test/EFCore.MySql.FunctionalTests/ManyToManyTrackingMySqlTestBase.cs index 82fd8de7f..b1978819f 100644 --- a/test/EFCore.MySql.FunctionalTests/ManyToManyTrackingMySqlTestBase.cs +++ b/test/EFCore.MySql.FunctionalTests/ManyToManyTrackingMySqlTestBase.cs @@ -26,8 +26,10 @@ protected ManyToManyTrackingMySqlTestBase(TFixture fixture) protected override void UseTransaction(DatabaseFacade facade, IDbContextTransaction transaction) => facade.UseTransaction(transaction.GetDbTransaction()); - public class ManyToManyTrackingMySqlFixtureBase : ManyToManyTrackingRelationalFixture + public class ManyToManyTrackingMySqlFixtureBase : ManyToManyTrackingRelationalFixture, ITestSqlLoggerFactory { + public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; + protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext context) diff --git a/test/EFCore.MySql.FunctionalTests/MigrationsInfrastructureMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/MigrationsInfrastructureMySqlTest.cs index ba0b81774..2dbdc139d 100644 --- a/test/EFCore.MySql.FunctionalTests/MigrationsInfrastructureMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/MigrationsInfrastructureMySqlTest.cs @@ -52,524 +52,127 @@ public override void Can_generate_no_migration_script() ignoreLineEndingDifferences: true); } - public override void Can_generate_up_scripts() + public override void Can_apply_one_migration() { - base.Can_generate_up_scripts(); + base.Can_apply_one_migration(); - Assert.Equal( - @"CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( - `MigrationId` varchar(150) CHARACTER SET utf8mb4 NOT NULL, - `ProductVersion` varchar(32) CHARACTER SET utf8mb4 NOT NULL, - CONSTRAINT `PK___EFMigrationsHistory` PRIMARY KEY (`MigrationId`) -) CHARACTER SET=utf8mb4; - -START TRANSACTION; - -CREATE TABLE `Table1` ( - `Id` int NOT NULL, - `Foo` int NOT NULL, - `Description` longtext NOT NULL, - CONSTRAINT `PK_Table1` PRIMARY KEY (`Id`) -); - -INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000001_Migration1', '7.0.0-test'); - -COMMIT; - -START TRANSACTION; - -ALTER TABLE `Table1` RENAME COLUMN `Foo` TO `Bar`; - -INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000002_Migration2', '7.0.0-test'); - -COMMIT; - -START TRANSACTION; - -INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000003_Migration3', '7.0.0-test'); - -COMMIT; - -START TRANSACTION; - -INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000004_Migration4', '7.0.0-test'); - -COMMIT; - -START TRANSACTION; - -INSERT INTO Table1 (Id, Bar, Description) VALUES (-1, ' ', 'Value With - -Empty Lines') - -INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000005_Migration5', '7.0.0-test'); - -COMMIT; - -START TRANSACTION; - -INSERT INTO Table1 (Id, Bar, Description) VALUES (-2, ' ', 'GO -Value With - -Empty Lines') - -INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000006_Migration6', '7.0.0-test'); - -COMMIT; - -START TRANSACTION; - -INSERT INTO Table1 (Id, Bar, Description) VALUES (-3, ' ', 'GO -Value With - -GO - -Empty Lines -GO') - -INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000007_Migration7', '7.0.0-test'); - -COMMIT; - -", - Sql, - ignoreLineEndingDifferences: true); + Assert.Null(Sql); } - public override void Can_generate_one_up_script() + public override void Can_apply_one_migration_in_parallel() { - base.Can_generate_one_up_script(); - - Assert.Equal( - @"START TRANSACTION; - -ALTER TABLE `Table1` RENAME COLUMN `Foo` TO `Bar`; + base.Can_apply_one_migration_in_parallel(); -INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000002_Migration2', '7.0.0-test'); - -COMMIT; - -", - Sql, - ignoreLineEndingDifferences: true); + Assert.Null(Sql); } - public override void Can_generate_up_script_using_names() + public override void Can_apply_second_migration_in_parallel() { - base.Can_generate_up_script_using_names(); + base.Can_apply_second_migration_in_parallel(); - Assert.Equal( - @"START TRANSACTION; - -ALTER TABLE `Table1` RENAME COLUMN `Foo` TO `Bar`; - -INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000002_Migration2', '7.0.0-test'); - -COMMIT; - -", - Sql, - ignoreLineEndingDifferences: true); + Assert.Null(Sql); } - public override void Can_generate_idempotent_up_scripts() + public override async Task Can_apply_one_migration_in_parallel_async() { - base.Can_generate_idempotent_up_scripts(); + await base.Can_apply_one_migration_in_parallel_async(); - Assert.Equal(@"CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( - `MigrationId` varchar(150) CHARACTER SET utf8mb4 NOT NULL, - `ProductVersion` varchar(32) CHARACTER SET utf8mb4 NOT NULL, - CONSTRAINT `PK___EFMigrationsHistory` PRIMARY KEY (`MigrationId`) -) CHARACTER SET=utf8mb4; - -START TRANSACTION; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000001_Migration1') THEN - - CREATE TABLE `Table1` ( - `Id` int NOT NULL, - `Foo` int NOT NULL, - `Description` longtext NOT NULL, - CONSTRAINT `PK_Table1` PRIMARY KEY (`Id`) - ); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000001_Migration1') THEN - - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000001_Migration1', '7.0.0-test'); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -COMMIT; - -START TRANSACTION; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000002_Migration2') THEN - - ALTER TABLE `Table1` RENAME COLUMN `Foo` TO `Bar`; - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000002_Migration2') THEN - - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000002_Migration2', '7.0.0-test'); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -COMMIT; - -START TRANSACTION; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000003_Migration3') THEN - - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000003_Migration3', '7.0.0-test'); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -COMMIT; - -START TRANSACTION; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000004_Migration4') THEN - - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000004_Migration4', '7.0.0-test'); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -COMMIT; - -START TRANSACTION; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000005_Migration5') THEN - - INSERT INTO Table1 (Id, Bar, Description) VALUES (-1, ' ', 'Value With - - Empty Lines') - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000005_Migration5') THEN - - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000005_Migration5', '7.0.0-test'); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -COMMIT; - -START TRANSACTION; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000006_Migration6') THEN - - INSERT INTO Table1 (Id, Bar, Description) VALUES (-2, ' ', 'GO - Value With - - Empty Lines') - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000006_Migration6') THEN - - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000006_Migration6', '7.0.0-test'); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -COMMIT; - -START TRANSACTION; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000007_Migration7') THEN - - INSERT INTO Table1 (Id, Bar, Description) VALUES (-3, ' ', 'GO - Value With - - GO - - Empty Lines - GO') - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000007_Migration7') THEN - - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000007_Migration7', '7.0.0-test'); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -COMMIT; - -", - Sql, - ignoreLineEndingDifferences: true); + Assert.Null(Sql); } - public override void Can_generate_down_scripts() + public override async Task Can_apply_second_migration_in_parallel_async() { - base.Can_generate_down_scripts(); - - Assert.Equal( - @"START TRANSACTION; - -ALTER TABLE `Table1` RENAME COLUMN `Bar` TO `Foo`; - -DELETE FROM `__EFMigrationsHistory` -WHERE `MigrationId` = '00000000000002_Migration2'; - -COMMIT; - -START TRANSACTION; - -DROP TABLE `Table1`; - -DELETE FROM `__EFMigrationsHistory` -WHERE `MigrationId` = '00000000000001_Migration1'; - -COMMIT; - -", - Sql, - ignoreLineEndingDifferences: true); - } - - public override void Can_generate_one_down_script() - { - base.Can_generate_one_down_script(); - - Assert.Equal( - @"START TRANSACTION; - -ALTER TABLE `Table1` RENAME COLUMN `Bar` TO `Foo`; - -DELETE FROM `__EFMigrationsHistory` -WHERE `MigrationId` = '00000000000002_Migration2'; - -COMMIT; - -", - Sql, - ignoreLineEndingDifferences: true); - } - - public override void Can_generate_down_script_using_names() - { - base.Can_generate_down_script_using_names(); - - Assert.Equal( - @"START TRANSACTION; - -ALTER TABLE `Table1` RENAME COLUMN `Bar` TO `Foo`; - -DELETE FROM `__EFMigrationsHistory` -WHERE `MigrationId` = '00000000000002_Migration2'; - -COMMIT; - -", - Sql, - ignoreLineEndingDifferences: true); + await base.Can_apply_second_migration_in_parallel_async(); + + Assert.Null(Sql); } - public override void Can_generate_idempotent_down_scripts() + public override async Task Can_generate_up_and_down_scripts() { - base.Can_generate_idempotent_down_scripts(); + await base.Can_generate_up_and_down_scripts(); Assert.Equal( - @"START TRANSACTION; +""" +CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( + `MigrationId` varchar(150) CHARACTER SET utf8mb4 NOT NULL, + `ProductVersion` varchar(32) CHARACTER SET utf8mb4 NOT NULL, + CONSTRAINT `PK___EFMigrationsHistory` PRIMARY KEY (`MigrationId`) +) CHARACTER SET=utf8mb4; -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000002_Migration2') THEN +START TRANSACTION; +CREATE TABLE `Table1` ( + `Id` int NOT NULL, + `Foo` int NOT NULL, + `Description` longtext NOT NULL, + CONSTRAINT `PK_Table1` PRIMARY KEY (`Id`) +); - ALTER TABLE `Table1` RENAME COLUMN `Bar` TO `Foo`; +INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) +VALUES ('00000000000001_Migration1', '7.0.0-test'); - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; +ALTER TABLE `Table1` RENAME COLUMN `Foo` TO `Bar`; -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000002_Migration2') THEN +INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) +VALUES ('00000000000002_Migration2', '7.0.0-test'); + +INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) +VALUES ('00000000000003_Migration3', '7.0.0-test'); - DELETE FROM `__EFMigrationsHistory` - WHERE `MigrationId` = '00000000000002_Migration2'; +INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) +VALUES ('00000000000004_Migration4', '7.0.0-test'); - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; +INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) +VALUES ('00000000000005_Migration5', '7.0.0-test'); + +INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) +VALUES ('00000000000006_Migration6', '7.0.0-test'); + +INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) +VALUES ('00000000000007_Migration7', '7.0.0-test'); COMMIT; START TRANSACTION; +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000007_Migration7'; -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000001_Migration1') THEN +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000006_Migration6'; - DROP TABLE `Table1`; +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000005_Migration5'; - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000004_Migration4'; -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000001_Migration1') THEN +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000003_Migration3'; - DELETE FROM `__EFMigrationsHistory` - WHERE `MigrationId` = '00000000000001_Migration1'; +ALTER TABLE `Table1` RENAME COLUMN `Bar` TO `Foo`; - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000002_Migration2'; + +DROP TABLE `Table1`; + +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000001_Migration1'; COMMIT; -", + +""", Sql, ignoreLineEndingDifferences: true); } - public override void Can_get_active_provider() - { - base.Can_get_active_provider(); - - Assert.Equal("Pomelo.EntityFrameworkCore.MySql", ActiveProvider); - } - - public override void Can_generate_up_scripts_noTransactions() + public override async Task Can_generate_up_and_down_scripts_noTransactions() { - base.Can_generate_up_scripts_noTransactions(); + await base.Can_generate_up_and_down_scripts_noTransactions(); Assert.Equal( - @"CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( +""" +CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( `MigrationId` varchar(150) CHARACTER SET utf8mb4 NOT NULL, `ProductVersion` varchar(32) CHARACTER SET utf8mb4 NOT NULL, CONSTRAINT `PK___EFMigrationsHistory` PRIMARY KEY (`MigrationId`) @@ -596,48 +199,116 @@ public override void Can_generate_up_scripts_noTransactions() INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) VALUES ('00000000000004_Migration4', '7.0.0-test'); -INSERT INTO Table1 (Id, Bar, Description) VALUES (-1, ' ', 'Value With +INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) +VALUES ('00000000000005_Migration5', '7.0.0-test'); -Empty Lines') +INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) +VALUES ('00000000000006_Migration6', '7.0.0-test'); INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000005_Migration5', '7.0.0-test'); +VALUES ('00000000000007_Migration7', '7.0.0-test'); + +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000007_Migration7'; + +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000006_Migration6'; + +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000005_Migration5'; + +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000004_Migration4'; + +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000003_Migration3'; + +ALTER TABLE `Table1` RENAME COLUMN `Bar` TO `Foo`; + +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000002_Migration2'; + +DROP TABLE `Table1`; -INSERT INTO Table1 (Id, Bar, Description) VALUES (-2, ' ', 'GO -Value With +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000001_Migration1'; + + +""", + Sql, + ignoreLineEndingDifferences: true); + } + + public override async Task Can_generate_one_up_and_down_script() + { + await base.Can_generate_one_up_and_down_script(); -Empty Lines') + Assert.Equal( +""" +START TRANSACTION; +ALTER TABLE `Table1` RENAME COLUMN `Foo` TO `Bar`; INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000006_Migration6', '7.0.0-test'); +VALUES ('00000000000002_Migration2', '7.0.0-test'); + +COMMIT; + +START TRANSACTION; +ALTER TABLE `Table1` RENAME COLUMN `Bar` TO `Foo`; + +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000002_Migration2'; + +COMMIT; -INSERT INTO Table1 (Id, Bar, Description) VALUES (-3, ' ', 'GO -Value With -GO +""", + Sql, + ignoreLineEndingDifferences: true); + } + + public override async Task Can_generate_up_and_down_script_using_names() + { + await base.Can_generate_up_and_down_script_using_names(); -Empty Lines -GO') + Assert.Equal( +""" +START TRANSACTION; +ALTER TABLE `Table1` RENAME COLUMN `Foo` TO `Bar`; INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) -VALUES ('00000000000007_Migration7', '7.0.0-test'); +VALUES ('00000000000002_Migration2', '7.0.0-test'); -", +COMMIT; + +START TRANSACTION; +ALTER TABLE `Table1` RENAME COLUMN `Bar` TO `Foo`; + +DELETE FROM `__EFMigrationsHistory` +WHERE `MigrationId` = '00000000000002_Migration2'; + +COMMIT; + + +""", Sql, ignoreLineEndingDifferences: true); } - public override void Can_generate_idempotent_up_scripts_noTransactions() + public override async Task Can_generate_idempotent_up_and_down_scripts() { - base.Can_generate_idempotent_up_scripts_noTransactions(); + var exception = await Assert.ThrowsAsync(() => base.Can_generate_idempotent_up_and_down_scripts()); + Assert.Equal("'DELIMITER' should not be used with MySqlConnector. See https://mysqlconnector.net/delimiter", exception.Message); Assert.Equal( - @"CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( +""" +CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( `MigrationId` varchar(150) CHARACTER SET utf8mb4 NOT NULL, `ProductVersion` varchar(32) CHARACTER SET utf8mb4 NOT NULL, CONSTRAINT `PK___EFMigrationsHistory` PRIMARY KEY (`MigrationId`) ) CHARACTER SET=utf8mb4; +START TRANSACTION; DROP PROCEDURE IF EXISTS MigrationsScript; DELIMITER // CREATE PROCEDURE MigrationsScript() @@ -701,45 +372,39 @@ IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000 CALL MigrationsScript(); DROP PROCEDURE MigrationsScript; -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000003_Migration3') THEN - - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000003_Migration3', '7.0.0-test'); +COMMIT; - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000004_Migration4') THEN +""", + Sql, + ignoreLineEndingDifferences: true); + } - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000004_Migration4', '7.0.0-test'); + public override async Task Can_generate_idempotent_up_and_down_scripts_noTransactions() + { + var exception = await Assert.ThrowsAsync(() => base.Can_generate_idempotent_up_and_down_scripts_noTransactions()); - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; + Assert.Equal("'DELIMITER' should not be used with MySqlConnector. See https://mysqlconnector.net/delimiter", exception.Message); + Assert.Equal( +""" +CREATE TABLE IF NOT EXISTS `__EFMigrationsHistory` ( + `MigrationId` varchar(150) CHARACTER SET utf8mb4 NOT NULL, + `ProductVersion` varchar(32) CHARACTER SET utf8mb4 NOT NULL, + CONSTRAINT `PK___EFMigrationsHistory` PRIMARY KEY (`MigrationId`) +) CHARACTER SET=utf8mb4; DROP PROCEDURE IF EXISTS MigrationsScript; DELIMITER // CREATE PROCEDURE MigrationsScript() BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000005_Migration5') THEN - - INSERT INTO Table1 (Id, Bar, Description) VALUES (-1, ' ', 'Value With + IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000001_Migration1') THEN - Empty Lines') + CREATE TABLE `Table1` ( + `Id` int NOT NULL, + `Foo` int NOT NULL, + `Description` longtext NOT NULL, + CONSTRAINT `PK_Table1` PRIMARY KEY (`Id`) + ); END IF; END // @@ -751,10 +416,10 @@ INSERT INTO Table1 (Id, Bar, Description) VALUES (-1, ' ', 'Value With DELIMITER // CREATE PROCEDURE MigrationsScript() BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000005_Migration5') THEN + IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000001_Migration1') THEN INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000005_Migration5', '7.0.0-test'); + VALUES ('00000000000001_Migration1', '7.0.0-test'); END IF; END // @@ -766,12 +431,9 @@ IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000 DELIMITER // CREATE PROCEDURE MigrationsScript() BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000006_Migration6') THEN - - INSERT INTO Table1 (Id, Bar, Description) VALUES (-2, ' ', 'GO - Value With + IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000002_Migration2') THEN - Empty Lines') + ALTER TABLE `Table1` RENAME COLUMN `Foo` TO `Bar`; END IF; END // @@ -783,30 +445,10 @@ Value With DELIMITER // CREATE PROCEDURE MigrationsScript() BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000006_Migration6') THEN + IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000002_Migration2') THEN INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000006_Migration6', '7.0.0-test'); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; - -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000007_Migration7') THEN - - INSERT INTO Table1 (Id, Bar, Description) VALUES (-3, ' ', 'GO - Value With - - GO - - Empty Lines - GO') + VALUES ('00000000000002_Migration2', '7.0.0-test'); END IF; END // @@ -814,26 +456,19 @@ Empty Lines CALL MigrationsScript(); DROP PROCEDURE MigrationsScript; -DROP PROCEDURE IF EXISTS MigrationsScript; -DELIMITER // -CREATE PROCEDURE MigrationsScript() -BEGIN - IF NOT EXISTS(SELECT 1 FROM `__EFMigrationsHistory` WHERE `MigrationId` = '00000000000007_Migration7') THEN - - INSERT INTO `__EFMigrationsHistory` (`MigrationId`, `ProductVersion`) - VALUES ('00000000000007_Migration7', '7.0.0-test'); - - END IF; -END // -DELIMITER ; -CALL MigrationsScript(); -DROP PROCEDURE MigrationsScript; -", +""", Sql, ignoreLineEndingDifferences: true); } + public override void Can_get_active_provider() + { + base.Can_get_active_provider(); + + Assert.Equal("Pomelo.EntityFrameworkCore.MySql", ActiveProvider); + } + [ConditionalFact(Skip = "TODO: Implement")] public override void Can_diff_against_2_2_model() { @@ -859,19 +494,42 @@ public override void Can_diff_against_2_1_ASP_NET_Identity_model() } public override void Can_apply_all_migrations() - => Assert.Throws(() => base.Can_apply_all_migrations()); + { + base.Can_apply_all_migrations(); + + Assert.Null(Sql); + } public override void Can_apply_range_of_migrations() - => Assert.Throws(() => base.Can_apply_range_of_migrations()); + { + base.Can_apply_range_of_migrations(); + + Assert.Null(Sql); + } public override void Can_revert_all_migrations() - => Assert.Throws(() => base.Can_revert_all_migrations()); + { + base.Can_revert_all_migrations(); + + Assert.Null(Sql); + } public override void Can_revert_one_migrations() - => Assert.Throws(() => base.Can_revert_one_migrations()); + { + base.Can_revert_one_migrations(); + + Assert.Null(Sql); + } - public override Task Can_apply_all_migrations_async() - => Assert.ThrowsAsync(() => base.Can_apply_all_migrations_async()); + protected override Task ExecuteSqlAsync(string value) + => ((MySqlTestStore)Fixture.TestStore).ExecuteNonQueryAsync(value); + + public override async Task Can_apply_all_migrations_async() + { + await base.Can_apply_all_migrations_async(); + + Assert.Null(Sql); + } public class MigrationsInfrastructureMySqlFixture : MigrationsInfrastructureFixtureBase { diff --git a/test/EFCore.MySql.FunctionalTests/MigrationsMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/MigrationsMySqlTest.cs index 462ede9f9..16f52e21a 100644 --- a/test/EFCore.MySql.FunctionalTests/MigrationsMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/MigrationsMySqlTest.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Linq; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; @@ -9,8 +9,10 @@ using Microsoft.EntityFrameworkCore.Migrations.Design; using Microsoft.EntityFrameworkCore.Scaffolding; using Microsoft.EntityFrameworkCore.Scaffolding.Metadata; +using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.TestUtilities; using Microsoft.Extensions.DependencyInjection; +using MySqlConnector; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.Infrastructure; using Pomelo.EntityFrameworkCore.MySql.Metadata.Internal; @@ -24,35 +26,73 @@ namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests { public class MigrationsMySqlTest : MigrationsTestBase { + private readonly IRelationalTypeMappingSource _typeMappingSource; + public MigrationsMySqlTest(MigrationsMySqlFixture fixture, ITestOutputHelper testOutputHelper) : base(fixture) { Fixture.TestSqlLoggerFactory.Clear(); //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); + + _typeMappingSource = Fixture.ServiceProvider.GetService(); } - [ConditionalTheory(Skip = "TODO: Syntax issue in MySQL 7 only.")] - public override Task Alter_check_constraint() + public override async Task Alter_check_constraint() { - return base.Alter_check_constraint(); + await base.Alter_check_constraint(); + + AssertSql( +""" +ALTER TABLE `People` DROP CONSTRAINT `CK_People_Foo`; +""", + // + """ +ALTER TABLE `People` ADD CONSTRAINT `CK_People_Foo` CHECK (`DriverLicense` > 1); +"""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Alter_column_make_computed(bool? stored) + public override async Task Alter_column_make_computed(bool? stored) { - return base.Alter_column_make_computed(stored); + if (stored == true) + { + await base.Alter_column_make_computed(stored); + + var computedColumnTypeSql = stored == true ? " STORED" : ""; + + AssertSql( +$""" +ALTER TABLE `People` MODIFY COLUMN `Sum` int AS (`X` + `Y`){computedColumnTypeSql}; +"""); + } + else + { + var exception = await Assert.ThrowsAsync(() => base.Alter_column_make_computed(stored)); + Assert.True(exception.Message is "'Changing the STORED status' is not supported for generated columns." + or "This is not yet supported for generated columns"); + } } - [ConditionalTheory(Skip = "TODO")] - public override Task Add_column_computed_with_collation(bool stored) + public override async Task Add_column_computed_with_collation(bool stored) { - return base.Add_column_computed_with_collation(stored); + await base.Add_column_computed_with_collation(stored); + + var computedColumnTypeSql = stored ? " STORED" : ""; + var nullableGeneratedColumnSql = AppConfig.ServerVersion.Supports.NullableGeneratedColumns ? " NULL" : string.Empty; + + AssertSql( +$""" +ALTER TABLE `People` ADD `Name` longtext CHARACTER SET utf8mb4 COLLATE {NonDefaultCollation} AS ('hello'){computedColumnTypeSql}{nullableGeneratedColumnSql}; +"""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Add_column_with_collation() + public override async Task Add_column_with_collation() { - return base.Add_column_with_collation(); + await base.Add_column_with_collation(); + + AssertSql( +$""" +ALTER TABLE `People` ADD `Name` longtext CHARACTER SET utf8mb4 COLLATE {NonDefaultCollation} NULL; +"""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.DefaultExpression), nameof(ServerVersionSupport.AlternativeDefaultExpression))] @@ -268,52 +308,83 @@ await Test( }); } - [ConditionalTheory(Skip = "TODO")] + [ConditionalTheory(Skip = "For this to work, either MySqlMigrator needs to be involved, or the primary key related stored procedures need to be handled by MySqlMigrationsSqlGenerator instead. The later is probably the way to go. We should move the primary key related stored procedures to its own service, so ti can be potentially be customized by users.")] public override async Task Add_primary_key_string() { await base.Add_primary_key_string(); + + AssertSql(""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Add_primary_key_composite_with_name() + public override async Task Add_primary_key_composite_with_name() { - return base.Add_primary_key_composite_with_name(); + await base.Add_primary_key_composite_with_name(); + + AssertSql( +""" +ALTER TABLE `People` ADD CONSTRAINT `PK_Foo` PRIMARY KEY (`SomeField1`, `SomeField2`); +"""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Add_primary_key_with_name() + [ConditionalTheory(Skip = "For this to work, either MySqlMigrator needs to be involved, or the primary key related stored procedures need to be handled by MySqlMigrationsSqlGenerator instead. The later is probably the way to go. We should move the primary key related stored procedures to its own service, so ti can be potentially be customized by users.")] + public override async Task Add_primary_key_with_name() { - return base.Add_primary_key_with_name(); + await base.Add_primary_key_with_name(); + + AssertSql(""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Add_unique_constraint() + [ConditionalTheory(Skip = "Are we not scaffolding unique constraints yet?")] + public override async Task Add_unique_constraint() { - return base.Add_unique_constraint(); + await base.Add_unique_constraint(); + + AssertSql(""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Add_unique_constraint_composite_with_name() + [ConditionalTheory(Skip = "Are we not scaffolding unique constraints yet?")] + public override async Task Add_unique_constraint_composite_with_name() { - return base.Add_unique_constraint_composite_with_name(); + await base.Add_unique_constraint_composite_with_name(); + + AssertSql(""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Alter_column_change_computed_type() + public override async Task Alter_column_change_computed_type() { - return base.Alter_column_change_computed_type(); + var exception = await Assert.ThrowsAsync(() => base.Alter_column_change_computed_type()); + Assert.True(exception.Message is "'Changing the STORED status' is not supported for generated columns." + or "This is not yet supported for generated columns"); } - [ConditionalTheory(Skip = "TODO")] - public override Task Alter_column_change_type() + public override async Task Alter_column_change_type() { - return base.Alter_column_change_type(); + // await base.Alter_column_change_type(); + await Test( + builder => builder.Entity("People").Property("Id"), + builder => builder.Entity("People").Property("SomeColumn"), + builder => builder.Entity("People").Property("SomeColumn"), + model => + { + var table = Assert.Single(model.Tables); + var column = Assert.Single(table.Columns, c => c.Name == "SomeColumn"); + Assert.StartsWith(_typeMappingSource.FindMapping(typeof(long)).StoreTypeNameBase, column.StoreType); + }); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `SomeColumn` bigint NOT NULL; +"""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Alter_column_set_collation() + public override async Task Alter_column_set_collation() { - return base.Alter_column_set_collation(); + await base.Alter_column_set_collation(); + + AssertSql( +$""" +ALTER TABLE `People` MODIFY COLUMN `Name` longtext CHARACTER SET utf8mb4 COLLATE {NonDefaultCollation} NULL; +"""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] @@ -322,19 +393,24 @@ public override async Task Alter_sequence_all_settings() await base.Alter_sequence_all_settings(); AssertSql( - """ +""" ALTER SEQUENCE `foo` INCREMENT BY 2 MINVALUE -5 MAXVALUE 10 CYCLE; """, // - """ +""" ALTER SEQUENCE `foo` START WITH -3 RESTART; """); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] - public override Task Alter_sequence_increment_by() + public override async Task Alter_sequence_increment_by() { - return base.Alter_sequence_increment_by(); + await base.Alter_sequence_increment_by(); + + AssertSql( +""" +ALTER SEQUENCE `foo` INCREMENT BY 2 NO MINVALUE NO MAXVALUE NOCYCLE; +"""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] @@ -351,37 +427,63 @@ public override async Task Alter_table_add_comment_non_default_schema() await base.Alter_table_add_comment_non_default_schema(); AssertSql( - @"ALTER TABLE `SomeOtherSchema_People` COMMENT 'Table comment';"); +""" +ALTER TABLE `People` COMMENT 'Table comment'; +"""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Create_index_with_filter() + [ConditionalFact(Skip = "MySQL does not support filtered indices.")] + public override async Task Create_index_with_filter() { - return base.Create_index_with_filter(); + await base.Create_index_with_filter(); + + AssertSql(""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Create_schema() + public override async Task Create_schema() { - return base.Create_schema(); + await base.Create_schema(); + + AssertSql( +""" +CREATE TABLE `People` ( + `Id` int NOT NULL AUTO_INCREMENT, + CONSTRAINT `PK_People` PRIMARY KEY (`Id`) +) CHARACTER SET=utf8mb4; +"""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] - public override Task Create_sequence() + public override async Task Create_sequence() { - return base.Create_sequence(); + await base.Create_sequence(); + + AssertSql( +""" +CREATE SEQUENCE `TestSequence` START WITH 1 INCREMENT BY 1 NOCYCLE; +"""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] - public override Task Create_sequence_long() + public override async Task Create_sequence_long() { - return base.Create_sequence_long(); + await base.Create_sequence_long(); + + AssertSql( +""" +CREATE SEQUENCE `TestSequence` START WITH 1 INCREMENT BY 1 NOCYCLE; +"""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] - public override Task Create_sequence_short() + public override async Task Create_sequence_short() { - return base.Create_sequence_short(); + await base.Create_sequence_short(); + + AssertSql( +""" +CREATE SEQUENCE `TestSequence` START WITH 1 INCREMENT BY 1 NOCYCLE; +"""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] @@ -401,7 +503,7 @@ await Test( // Assert.Equal("TestSequence", sequence.Name); // Assert.Equal("dbo2", sequence.Schema); - Assert.Equal("dbo2_TestSequence", sequence.Name); + Assert.Equal("TestSequence", sequence.Name); Assert.Equal(3, sequence.StartValue); Assert.Equal(2, sequence.IncrementBy); @@ -412,14 +514,16 @@ await Test( AssertSql( """ -CREATE SEQUENCE `dbo2_TestSequence` START WITH 3 INCREMENT BY 2 MINVALUE 2 MAXVALUE 916 CYCLE; +CREATE SEQUENCE `TestSequence` START WITH 3 INCREMENT BY 2 MINVALUE 2 MAXVALUE 916 CYCLE; """); } - [ConditionalTheory(Skip = "TODO")] - public override Task Create_table_all_settings() + [ConditionalFact(Skip = "Are we not scaffolding unique constraints yet?")] + public override async Task Create_table_all_settings() { - return base.Create_table_all_settings(); + await base.Create_table_all_settings(); + + AssertSql(""); } public override async Task Create_table_with_multiline_comments() @@ -440,10 +544,12 @@ More information can be found in the docs.';"); } - [ConditionalTheory(Skip = "TODO")] - public override Task Create_unique_index_with_filter() + [ConditionalFact(Skip = "MySQL does not support filtered indices.")] + public override async Task Create_unique_index_with_filter() { - return base.Create_unique_index_with_filter(); + await base.Create_unique_index_with_filter(); + + AssertSql(""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.DescendingIndexes))] @@ -475,36 +581,52 @@ public override async Task Alter_index_change_sort_order() @"CREATE INDEX `IX_People_X_Y_Z` ON `People` (`X`, `Y` DESC, `Z`);"); } - [ConditionalTheory(Skip = "TODO: Syntax issue in MySQL 7 only.")] - public override Task Drop_check_constraint() + public override async Task Drop_check_constraint() { - return base.Drop_check_constraint(); + await base.Drop_check_constraint(); + + AssertSql( +""" +ALTER TABLE `People` DROP CONSTRAINT `CK_People_Foo`; +"""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Drop_column_primary_key() + [ConditionalFact(Skip = "For this to work, either MySqlMigrator needs to be involved, or the primary key related stored procedures need to be handled by MySqlMigrationsSqlGenerator instead. The later is probably the way to go. We should move the primary key related stored procedures to its own service, so ti can be potentially be customized by users.")] + public override async Task Drop_column_primary_key() { - return base.Drop_column_primary_key(); + await base.Drop_column_primary_key(); + + AssertSql(""); } - [ConditionalTheory(Skip = "TODO")] - public override Task Drop_primary_key_int() + [ConditionalFact(Skip = "For this to work, either MySqlMigrator needs to be involved, or the primary key related stored procedures need to be handled by MySqlMigrationsSqlGenerator instead. The later is probably the way to go. We should move the primary key related stored procedures to its own service, so ti can be potentially be customized by users.")] + public override async Task Drop_primary_key_int() { - return base.Drop_primary_key_int(); + await base.Drop_primary_key_int(); + + AssertSql(""); } - [ConditionalTheory(Skip = "TODO")] + [ConditionalFact(Skip = "For this to work, either MySqlMigrator needs to be involved, or the primary key related stored procedures need to be handled by MySqlMigrationsSqlGenerator instead. The later is probably the way to go. We should move the primary key related stored procedures to its own service, so ti can be potentially be customized by users.")] public override async Task Drop_primary_key_string() { await base.Drop_primary_key_string(); + + AssertSql(""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] - public override Task Drop_sequence() + public override async Task Drop_sequence() { - return base.Drop_sequence(); + await base.Drop_sequence(); + + AssertSql( +""" +DROP SEQUENCE `TestSequence`; +"""); } + [ConditionalFact(Skip = "There are no schemas in MySQL, that a sequence can be moved between.")] [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] public override async Task Move_sequence() { @@ -516,19 +638,45 @@ await Test( var sequence = Assert.Single(model.Sequences); // Assert.Equal("TestSequenceSchema", sequence.Schema); // Assert.Equal("TestSequence", sequence.Name); - Assert.Equal("TestSequenceSchema_TestSequenceMove", sequence.Name); + Assert.Equal("TestSequenceMove", sequence.Name); }); + AssertSql(""); + } + + [SupportedServerVersionCondition(nameof(ServerVersionSupport.DefaultExpression), nameof(ServerVersionSupport.AlternativeDefaultExpression))] + public override async Task Add_required_primitive_collection_with_custom_default_value_sql_to_existing_table() + { + // Classic/literal default values like `DEFAULT '[3, 2, 1]'` are not allowed for `json`, `blob` or `text` data types, but + // default *expressions* like `DEFAULT ('[3, 2, 1]')` are. + await base.Add_required_primitive_collection_with_custom_default_value_sql_to_existing_table_core("('[3, 2, 1]')"); + + AssertSql( +""" +ALTER TABLE `Customers` ADD `Numbers` longtext CHARACTER SET utf8mb4 NOT NULL DEFAULT ('[3, 2, 1]'); +"""); + } + + public override async Task Add_required_primitve_collection_with_custom_default_value_sql_to_existing_table() + { + // Classic/literal default values like `DEFAULT '[3, 2, 1]'` are not allowed for `json`, `blob` or `text` data types, but + // default *expressions* like `DEFAULT ('[3, 2, 1]')` are. + await base.Add_required_primitve_collection_with_custom_default_value_sql_to_existing_table_core("('[3, 2, 1]')"); + AssertSql( """ -ALTER TABLE `TestSequenceMove` RENAME `TestSequenceSchema_TestSequenceMove`; +ALTER TABLE `Customers` ADD `Numbers` longtext CHARACTER SET utf8mb4 NOT NULL DEFAULT ('[3, 2, 1]'); """); } - [ConditionalTheory(Skip = "TODO")] - public override Task Move_table() + public override async Task Move_table() { - return base.Move_table(); + await base.Move_table(); + + AssertSql( +""" +ALTER TABLE `TestTable` RENAME `TestTable`; +"""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] @@ -565,23 +713,58 @@ await Test( } } - [ConditionalTheory(Skip = "TODO")] - public override Task Rename_table_with_primary_key() + [ConditionalFact(Skip = "For this to work, either MySqlMigrator needs to be involved, or the primary key related stored procedures need to be handled by MySqlMigrationsSqlGenerator instead. The later is probably the way to go. We should move the primary key related stored procedures to its own service, so ti can be potentially be customized by users.")] + public override async Task Rename_table_with_primary_key() { - return base.Rename_table_with_primary_key(); + await base.Rename_table_with_primary_key(); + + AssertSql(""); } [SupportedServerVersionCondition(nameof(ServerVersionSupport.GeneratedColumns))] - public override Task Add_column_with_computedSql(bool? stored) - => base.Add_column_with_computedSql(stored); + public override async Task Add_column_with_computedSql(bool? stored) + { + await base.Add_column_with_computedSql(stored); + + var computedColumnTypeSql = stored == true ? " STORED" : ""; + var nullableGeneratedColumnSql = AppConfig.ServerVersion.Supports.NullableGeneratedColumns ? " NULL" : string.Empty; + + AssertSql( +$""" +ALTER TABLE `People` ADD `Sum` longtext CHARACTER SET utf8mb4 AS (`X` + `Y`){computedColumnTypeSql}{nullableGeneratedColumnSql}; +"""); + } [SupportedServerVersionCondition(nameof(ServerVersionSupport.GeneratedColumns))] - public override Task Create_table_with_computed_column(bool? stored) - => base.Create_table_with_computed_column(stored); + public override async Task Create_table_with_computed_column(bool? stored) + { + await base.Create_table_with_computed_column(stored); + + var computedColumnTypeSql = stored == true ? " STORED" : ""; + var nullableGeneratedColumnSql = AppConfig.ServerVersion.Supports.NullableGeneratedColumns ? " NULL" : string.Empty; + + AssertSql( +$""" +CREATE TABLE `People` ( + `Id` int NOT NULL AUTO_INCREMENT, + `Sum` longtext CHARACTER SET utf8mb4 AS (`X` + `Y`){computedColumnTypeSql}{nullableGeneratedColumnSql}, + `X` int NOT NULL, + `Y` int NOT NULL, + CONSTRAINT `PK_People` PRIMARY KEY (`Id`) +) CHARACTER SET=utf8mb4; +"""); + } [SupportedServerVersionCondition(nameof(ServerVersionSupport.GeneratedColumns))] - public override Task Alter_column_change_computed() - => base.Alter_column_change_computed(); + public override async Task Alter_column_change_computed() + { + await base.Alter_column_change_computed(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `Sum` int AS (`X` - `Y`); +"""); + } // We currently do not scaffold table options. // @@ -911,21 +1094,27 @@ await Test( }), result => { }); + var collationColumnName = AppConfig.ServerVersion.Supports.CollationCharacterSetApplicabilityWithFullCollationNameColumn + ? "FULL_COLLATION_NAME" + : "COLLATION_NAME"; + AssertSql( - @"set @__pomelo_TableCharset = ( - SELECT `ccsa`.`CHARACTER_SET_NAME` as `TABLE_CHARACTER_SET` - FROM `INFORMATION_SCHEMA`.`TABLES` as `t` - LEFT JOIN `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`COLLATION_NAME` = `t`.`TABLE_COLLATION` - WHERE `TABLE_SCHEMA` = SCHEMA() AND `TABLE_NAME` = 'IceCream' AND `TABLE_TYPE` IN ('BASE TABLE', 'VIEW')); +$""" +set @__pomelo_TableCharset = ( +SELECT `ccsa`.`CHARACTER_SET_NAME` as `TABLE_CHARACTER_SET` +FROM `INFORMATION_SCHEMA`.`TABLES` as `t` +LEFT JOIN `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`{collationColumnName}` = `t`.`TABLE_COLLATION` +WHERE `TABLE_SCHEMA` = SCHEMA() AND `TABLE_NAME` = 'IceCream' AND `TABLE_TYPE` IN ('BASE TABLE', 'VIEW')); SET @__pomelo_SqlExpr = CONCAT('ALTER TABLE `IceCream` CHARACTER SET = ', @__pomelo_TableCharset, ';'); PREPARE __pomelo_SqlExprExecute FROM @__pomelo_SqlExpr; EXECUTE __pomelo_SqlExprExecute; -DEALLOCATE PREPARE __pomelo_SqlExprExecute;", - // - $@"ALTER TABLE `IceCream` MODIFY COLUMN `Name` longtext COLLATE {NonDefaultCollation} NULL;", - // - $@"ALTER TABLE `IceCream` MODIFY COLUMN `Brand` longtext COLLATE {NonDefaultCollation2} NULL;"); +DEALLOCATE PREPARE __pomelo_SqlExprExecute; +""", +// +$@"ALTER TABLE `IceCream` MODIFY COLUMN `Name` longtext COLLATE {NonDefaultCollation} NULL;", +// +$@"ALTER TABLE `IceCream` MODIFY COLUMN `Brand` longtext COLLATE {NonDefaultCollation2} NULL;"); } [ConditionalFact] @@ -1302,105 +1491,789 @@ public override Task Rename_table() }, withConventions: false); - #region ToJson - - public override Task Create_table_with_json_column() - => Assert.ThrowsAsync(() => base.Create_table_with_json_column()); + public override async Task Create_table() + { + await base.Create_table(); - public override Task Create_table_with_json_column_explicit_json_column_names() - => Assert.ThrowsAsync(() => base.Create_table_with_json_column_explicit_json_column_names()); + AssertSql( +""" +CREATE TABLE `People` ( + `Id` int NOT NULL AUTO_INCREMENT, + `Name` longtext CHARACTER SET utf8mb4 NULL, + CONSTRAINT `PK_People` PRIMARY KEY (`Id`) +) CHARACTER SET=utf8mb4; +"""); + } - public override Task Rename_table_with_json_column() - => Assert.ThrowsAsync(() => base.Rename_table_with_json_column()); + public override async Task Create_table_no_key() + { + await base.Create_table_no_key(); - public override Task Add_json_columns_to_existing_table() - => Assert.ThrowsAsync(() => base.Add_json_columns_to_existing_table()); + AssertSql( +""" +CREATE TABLE `Anonymous` ( + `SomeColumn` int NOT NULL +) CHARACTER SET=utf8mb4; +"""); + } - public override Task Convert_json_entities_to_regular_owned() - => Assert.ThrowsAsync(() => base.Convert_json_entities_to_regular_owned()); + public override async Task Create_table_with_comments() + { + await base.Create_table_with_comments(); - public override Task Convert_regular_owned_entities_to_json() - => Assert.ThrowsAsync(() => base.Convert_regular_owned_entities_to_json()); + AssertSql( +""" +CREATE TABLE `People` ( + `Id` int NOT NULL AUTO_INCREMENT, + `Name` longtext CHARACTER SET utf8mb4 NULL COMMENT 'Column comment', + CONSTRAINT `PK_People` PRIMARY KEY (`Id`) +) CHARACTER SET=utf8mb4 COMMENT='Table comment'; +"""); + } - public override Task Convert_string_column_to_a_json_column_containing_reference() - => Assert.ThrowsAsync(() => base.Convert_string_column_to_a_json_column_containing_reference()); + public override async Task Alter_table_add_comment() + { + await base.Alter_table_add_comment(); - public override Task Convert_string_column_to_a_json_column_containing_required_reference() - => Assert.ThrowsAsync(() => base.Convert_string_column_to_a_json_column_containing_required_reference()); + AssertSql( +""" +ALTER TABLE `People` COMMENT 'Table comment'; +"""); + } - public override Task Convert_string_column_to_a_json_column_containing_collection() - => Assert.ThrowsAsync(() => base.Convert_string_column_to_a_json_column_containing_collection()); + public override async Task Alter_table_change_comment() + { + await base.Alter_table_change_comment(); - public override Task Drop_json_columns_from_existing_table() - => Assert.ThrowsAsync(() => base.Drop_json_columns_from_existing_table()); + AssertSql( +""" +ALTER TABLE `People` COMMENT 'Table comment2'; +"""); + } - public override Task Rename_json_column() - => Assert.ThrowsAsync(() => base.Rename_json_column()); + public override async Task Alter_table_remove_comment() + { + await base.Alter_table_remove_comment(); - #endregion ToJson + AssertSql( +""" +ALTER TABLE `People` COMMENT ''; +"""); + } - // The constraint name for a primary key is always PRIMARY in MySQL. - protected override bool AssertConstraintNames - => false; + public override async Task Drop_table() + { + await base.Drop_table(); - protected virtual string DefaultCollation => ((MySqlTestStore)Fixture.TestStore).DatabaseCollation; + AssertSql( +""" +DROP TABLE `People`; +"""); + } - protected override string NonDefaultCollation - => DefaultCollation == ((MySqlTestStore)Fixture.TestStore).ServerVersion.Value.DefaultUtf8CsCollation - ? ((MySqlTestStore)Fixture.TestStore).ServerVersion.Value.DefaultUtf8CiCollation - : ((MySqlTestStore)Fixture.TestStore).ServerVersion.Value.DefaultUtf8CsCollation; + public override async Task Add_column_with_defaultValueSql_unspecified() + { + await base.Add_column_with_defaultValueSql_unspecified(); - protected virtual string NonDefaultCollation2 - => "utf8mb4_german2_ci"; + AssertSql(); + } - protected virtual string DefaultCharSet => ((MySqlTestStore)Fixture.TestStore).DatabaseCharSet; - protected virtual string NonDefaultCharSet => "latin1"; - protected virtual string NonDefaultCharSet2 => "ascii"; + public override async Task Add_column_with_defaultValue_unspecified() + { + await base.Add_column_with_defaultValue_unspecified(); - protected virtual TestHelpers TestHelpers => MySqlTestHelpers.Instance; + AssertSql(); + } - protected virtual Task Test( - Action buildCommonAction, - Action buildSourceAction, - Action buildTargetAction, - Action migrationBuilderAction, - Action asserter, - bool withConventions = true) + public override async Task Add_column_with_computedSql_unspecified() { - var services = TestHelpers.CreateContextServices(); - var modelRuntimeInitializer = services.GetRequiredService(); + await base.Add_column_with_computedSql_unspecified(); - // Build the source model, possibly with conventions - var sourceModelBuilder = CreateModelBuilder(withConventions); - buildCommonAction(sourceModelBuilder); - buildSourceAction(sourceModelBuilder); - var preSnapshotSourceModel = modelRuntimeInitializer.Initialize( - (IModel)sourceModelBuilder.Model, designTime: true, validationLogger: null); + AssertSql(); + } - // Round-trip the source model through a snapshot, compiling it and then extracting it back again. - // This simulates the real-world migration flow and can expose errors in snapshot generation - var migrationsCodeGenerator = Fixture.TestHelpers.CreateDesignServiceProvider().GetRequiredService(); - var sourceModelSnapshot = migrationsCodeGenerator.GenerateSnapshot( - modelSnapshotNamespace: null, typeof(DbContext), "MigrationsTestSnapshot", preSnapshotSourceModel); - var sourceModel = BuildModelFromSnapshotSource(sourceModelSnapshot); + public override async Task Add_column_with_required() + { + await base.Add_column_with_required(); - // Build the target model, possibly with conventions - var targetModelBuilder = CreateModelBuilder(withConventions); - buildCommonAction(targetModelBuilder); - buildTargetAction(targetModelBuilder); - var targetModel = modelRuntimeInitializer.Initialize( - (IModel)targetModelBuilder.Model, designTime: true, validationLogger: null); + AssertSql( +""" +ALTER TABLE `People` ADD `Name` longtext CHARACTER SET utf8mb4 NOT NULL; +"""); + } - var migrationBuilder = new MigrationBuilder(null); - migrationBuilderAction(migrationBuilder); + public override async Task Add_column_with_ansi() + { + await base.Add_column_with_ansi(); - return Test(sourceModel, targetModel, migrationBuilder.Operations, asserter); + AssertSql( +""" +ALTER TABLE `People` ADD `Name` longtext CHARACTER SET utf8mb4 NULL; +"""); } - private ModelBuilder CreateModelBuilder(bool withConventions) - => withConventions ? Fixture.TestHelpers.CreateConventionBuilder() : new ModelBuilder(new ConventionSet()); - - public class MigrationsMySqlFixture : MigrationsFixtureBase + public override async Task Add_column_with_max_length() + { + await base.Add_column_with_max_length(); + + AssertSql( +""" +ALTER TABLE `People` ADD `Name` varchar(30) CHARACTER SET utf8mb4 NULL; +"""); + } + + public override async Task Add_column_with_unbounded_max_length() + { + await base.Add_column_with_unbounded_max_length(); + + AssertSql( +""" +ALTER TABLE `People` ADD `Name` longtext CHARACTER SET utf8mb4 NULL; +"""); + } + + public override async Task Add_column_with_max_length_on_derived() + { + await base.Add_column_with_max_length_on_derived(); + + AssertSql(); + } + + public override async Task Add_column_with_fixed_length() + { + await base.Add_column_with_fixed_length(); + + AssertSql( +""" +ALTER TABLE `People` ADD `Name` char(100) CHARACTER SET utf8mb4 NULL; +"""); + } + + public override async Task Add_column_with_comment() + { + await base.Add_column_with_comment(); + + AssertSql( +""" +ALTER TABLE `People` ADD `FullName` longtext CHARACTER SET utf8mb4 NULL COMMENT 'My comment'; +"""); + } + + public override async Task Add_column_shared() + { + await base.Add_column_shared(); + + AssertSql(); + } + + public override async Task Add_column_with_check_constraint() + { + await base.Add_column_with_check_constraint(); + + AssertSql( +""" +ALTER TABLE `People` ADD `DriverLicense` int NOT NULL DEFAULT 0; +""", + // + """ +ALTER TABLE `People` ADD CONSTRAINT `CK_People_Foo` CHECK (`DriverLicense` > 0); +"""); + } + + public override async Task Alter_column_make_required_with_null_data() + { + await base.Alter_column_make_required_with_null_data(); + + AssertSql( +""" +UPDATE `People` SET `SomeColumn` = '' +WHERE `SomeColumn` IS NULL; +SELECT ROW_COUNT(); +""", + // + """ +ALTER TABLE `People` MODIFY COLUMN `SomeColumn` longtext CHARACTER SET utf8mb4 NOT NULL; +"""); + } + + public override async Task Alter_column_make_required_with_index() + { + await base.Alter_column_make_required_with_index(); + + AssertSql( +""" +UPDATE `People` SET `SomeColumn` = '' +WHERE `SomeColumn` IS NULL; +SELECT ROW_COUNT(); +""", + // + """ +ALTER TABLE `People` MODIFY COLUMN `SomeColumn` varchar(255) CHARACTER SET utf8mb4 NOT NULL; +"""); + } + + public override async Task Alter_column_make_required_with_composite_index() + { + await base.Alter_column_make_required_with_composite_index(); + + AssertSql( +""" +UPDATE `People` SET `FirstName` = '' +WHERE `FirstName` IS NULL; +SELECT ROW_COUNT(); +""", + // + """ +ALTER TABLE `People` MODIFY COLUMN `FirstName` varchar(255) CHARACTER SET utf8mb4 NOT NULL; +"""); + } + + public override async Task Alter_column_change_computed_recreates_indexes() + { + await base.Alter_column_change_computed_recreates_indexes(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `Sum` int AS (`X` - `Y`); +"""); + } + + public override async Task Alter_column_add_comment() + { + await base.Alter_column_add_comment(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `Id` int NOT NULL COMMENT 'Some comment' AUTO_INCREMENT; +"""); + } + + public override async Task Alter_computed_column_add_comment() + { + await base.Alter_computed_column_add_comment(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `SomeColumn` int AS (42) COMMENT 'Some comment'; +"""); + } + + public override async Task Alter_column_change_comment() + { + await base.Alter_column_change_comment(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `Id` int NOT NULL COMMENT 'Some comment2' AUTO_INCREMENT; +"""); + } + + public override async Task Alter_column_remove_comment() + { + await base.Alter_column_remove_comment(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `Id` int NOT NULL AUTO_INCREMENT; +"""); + } + + public override async Task Alter_column_reset_collation() + { + await base.Alter_column_reset_collation(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `Name` longtext CHARACTER SET utf8mb4 NULL; +"""); + } + + public override async Task Drop_column() + { + await base.Drop_column(); + + AssertSql( +""" +ALTER TABLE `People` DROP COLUMN `SomeColumn`; +"""); + } + + public override async Task Drop_column_computed_and_non_computed_with_dependency() + { + await base.Drop_column_computed_and_non_computed_with_dependency(); + + AssertSql( +""" +ALTER TABLE `People` DROP COLUMN `Y`; +""", + // + """ +ALTER TABLE `People` DROP COLUMN `X`; +"""); + } + + public override async Task Rename_column() + { + await base.Rename_column(); + + AssertSql( +""" +ALTER TABLE `People` RENAME COLUMN `SomeColumn` TO `SomeOtherColumn`; +"""); + } + + public override async Task Create_index() + { + await base.Create_index(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `FirstName` varchar(255) CHARACTER SET utf8mb4 NULL; +""", + // + """ +CREATE INDEX `IX_People_FirstName` ON `People` (`FirstName`); +"""); + } + + public override async Task Create_index_unique() + { + await base.Create_index_unique(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `LastName` varchar(255) CHARACTER SET utf8mb4 NULL; +""", + // + """ +ALTER TABLE `People` MODIFY COLUMN `FirstName` varchar(255) CHARACTER SET utf8mb4 NULL; +""", + // + """ +CREATE UNIQUE INDEX `IX_People_FirstName_LastName` ON `People` (`FirstName`, `LastName`); +"""); + } + + public override async Task Alter_index_make_unique() + { + await base.Alter_index_make_unique(); + + AssertSql( +""" +ALTER TABLE `People` DROP INDEX `IX_People_X`; +""", + // + """ +CREATE UNIQUE INDEX `IX_People_X` ON `People` (`X`); +"""); + } + + public override async Task Drop_index() + { + await base.Drop_index(); + + AssertSql( +""" +ALTER TABLE `People` DROP INDEX `IX_People_SomeField`; +"""); + } + + public override async Task Add_primary_key_int() + { + await base.Add_primary_key_int(); + + AssertSql( +""" +ALTER TABLE `People` MODIFY COLUMN `SomeField` int NOT NULL AUTO_INCREMENT, +ADD CONSTRAINT `PK_People` PRIMARY KEY (`SomeField`); +"""); + } + + public override async Task Add_foreign_key_with_name() + { + await base.Add_foreign_key_with_name(); + + AssertSql( +""" +CREATE INDEX `IX_Orders_CustomerId` ON `Orders` (`CustomerId`); +""", + // + """ +ALTER TABLE `Orders` ADD CONSTRAINT `FK_Foo` FOREIGN KEY (`CustomerId`) REFERENCES `Customers` (`Id`) ON DELETE CASCADE; +"""); + } + + public override async Task Drop_foreign_key() + { + await base.Drop_foreign_key(); + + AssertSql( +""" +ALTER TABLE `Orders` DROP FOREIGN KEY `FK_Orders_Customers_CustomerId`; +""", + // + """ +ALTER TABLE `Orders` DROP INDEX `IX_Orders_CustomerId`; +"""); + } + + public override async Task Drop_unique_constraint() + { + await base.Drop_unique_constraint(); + + AssertSql( +""" +ALTER TABLE `People` DROP KEY `AK_People_AlternateKeyColumn`; +"""); + } + + public override async Task Add_check_constraint_with_name() + { + await base.Add_check_constraint_with_name(); + + AssertSql( +""" +ALTER TABLE `People` ADD CONSTRAINT `CK_People_Foo` CHECK (`DriverLicense` > 0); +"""); + } + + public override async Task InsertDataOperation() + { + await base.InsertDataOperation(); + + AssertSql( +""" +INSERT INTO `Person` (`Id`, `Name`) +VALUES (1, 'Daenerys Targaryen'), +(2, 'John Snow'), +(3, 'Arya Stark'), +(4, 'Harry Strickland'), +(5, NULL); +"""); + } + + public override async Task DeleteDataOperation_simple_key() + { + await base.DeleteDataOperation_simple_key(); + + AssertSql( + AppConfig.ServerVersion.Supports.Returning + ? """ +DELETE FROM `Person` +WHERE `Id` = 2 +RETURNING 1; +""" + : """ +DELETE FROM `Person` +WHERE `Id` = 2; +SELECT ROW_COUNT(); +"""); + } + + public override async Task DeleteDataOperation_composite_key() + { + await base.DeleteDataOperation_composite_key(); + + AssertSql( + AppConfig.ServerVersion.Supports.Returning + ? """ +DELETE FROM `Person` +WHERE `AnotherId` = 12 AND `Id` = 2 +RETURNING 1; +""" + : """ +DELETE FROM `Person` +WHERE `AnotherId` = 12 AND `Id` = 2; +SELECT ROW_COUNT(); +"""); + } + + public override async Task UpdateDataOperation_simple_key() + { + await base.UpdateDataOperation_simple_key(); + + AssertSql( +""" +UPDATE `Person` SET `Name` = 'Another John Snow' +WHERE `Id` = 2; +SELECT ROW_COUNT(); +"""); + } + + public override async Task UpdateDataOperation_composite_key() + { + await base.UpdateDataOperation_composite_key(); + + AssertSql( +""" +UPDATE `Person` SET `Name` = 'Another John Snow' +WHERE `AnotherId` = 11 AND `Id` = 2; +SELECT ROW_COUNT(); +"""); + } + + public override async Task UpdateDataOperation_multiple_columns() + { + await base.UpdateDataOperation_multiple_columns(); + + AssertSql( +""" +UPDATE `Person` SET `Age` = 21, `Name` = 'Another John Snow' +WHERE `Id` = 2; +SELECT ROW_COUNT(); +"""); + } + + public override async Task SqlOperation() + { + await base.SqlOperation(); + + AssertSql( +""" +-- I <3 DDL +"""); + } + + public override async Task Create_table_with_complex_type_with_required_properties_on_derived_entity_in_TPH() + { + await base.Create_table_with_complex_type_with_required_properties_on_derived_entity_in_TPH(); + + AssertSql( +""" +CREATE TABLE `Contacts` ( + `Id` int NOT NULL AUTO_INCREMENT, + `Discriminator` varchar(8) CHARACTER SET utf8mb4 NOT NULL, + `Name` longtext CHARACTER SET utf8mb4 NULL, + `Number` int NULL, + `MyComplex_Prop` longtext NULL, + `MyComplex_MyNestedComplex_Bar` datetime(6) NULL, + `MyComplex_MyNestedComplex_Foo` int NULL, + CONSTRAINT `PK_Contacts` PRIMARY KEY (`Id`) +) CHARACTER SET=utf8mb4; +"""); + } + + public override async Task Add_required_primitive_collection_to_existing_table() + { + await base.Add_required_primitive_collection_to_existing_table(); + + AssertSql( +""" +ALTER TABLE `Customers` ADD `Numbers` longtext CHARACTER SET utf8mb4 NOT NULL; +"""); + } + + public override async Task Add_required_primitive_collection_with_custom_default_value_to_existing_table() + { + await base.Add_required_primitive_collection_with_custom_default_value_to_existing_table(); + + AssertSql( +""" +ALTER TABLE `Customers` ADD `Numbers` longtext CHARACTER SET utf8mb4 NOT NULL DEFAULT ('[1,2,3]'); +"""); + } + + public override async Task Add_required_primitive_collection_with_custom_converter_to_existing_table() + { + await base.Add_required_primitive_collection_with_custom_converter_to_existing_table(); + + AssertSql(); + } + + public override async Task Add_required_primitive_collection_with_custom_converter_and_custom_default_value_to_existing_table() + { + await base.Add_required_primitive_collection_with_custom_converter_and_custom_default_value_to_existing_table(); + + AssertSql( +""" +ALTER TABLE `Customers` ADD `Numbers` longtext CHARACTER SET utf8mb4 NOT NULL DEFAULT ('some numbers'); +"""); + } + + public override async Task Add_optional_primitive_collection_to_existing_table() + { + await base.Add_optional_primitive_collection_to_existing_table(); + + AssertSql( +""" +ALTER TABLE `Customers` ADD `Numbers` longtext CHARACTER SET utf8mb4 NULL; +"""); + } + + public override async Task Create_table_with_required_primitive_collection() + { + await base.Create_table_with_required_primitive_collection(); + + AssertSql( +""" +CREATE TABLE `Customers` ( + `Id` int NOT NULL AUTO_INCREMENT, + `Name` longtext CHARACTER SET utf8mb4 NULL, + `Numbers` longtext CHARACTER SET utf8mb4 NOT NULL, + CONSTRAINT `PK_Customers` PRIMARY KEY (`Id`) +) CHARACTER SET=utf8mb4; +"""); + } + + public override async Task Create_table_with_optional_primitive_collection() + { + await base.Create_table_with_optional_primitive_collection(); + + AssertSql( +""" +CREATE TABLE `Customers` ( + `Id` int NOT NULL AUTO_INCREMENT, + `Name` longtext CHARACTER SET utf8mb4 NULL, + `Numbers` longtext CHARACTER SET utf8mb4 NULL, + CONSTRAINT `PK_Customers` PRIMARY KEY (`Id`) +) CHARACTER SET=utf8mb4; +"""); + } + + public override async Task Add_required_primitve_collection_to_existing_table() + { + await base.Add_required_primitve_collection_to_existing_table(); + + AssertSql( +""" +ALTER TABLE `Customers` ADD `Numbers` longtext CHARACTER SET utf8mb4 NOT NULL; +"""); + } + + public override async Task Add_required_primitve_collection_with_custom_default_value_to_existing_table() + { + await base.Add_required_primitve_collection_with_custom_default_value_to_existing_table(); + + AssertSql( +""" +ALTER TABLE `Customers` ADD `Numbers` longtext CHARACTER SET utf8mb4 NOT NULL DEFAULT ('[1,2,3]'); +"""); + } + + public override async Task Add_required_primitve_collection_with_custom_converter_to_existing_table() + { + await base.Add_required_primitve_collection_with_custom_converter_to_existing_table(); + + AssertSql(); + } + + public override async Task Add_required_primitve_collection_with_custom_converter_and_custom_default_value_to_existing_table() + { + await base.Add_required_primitve_collection_with_custom_converter_and_custom_default_value_to_existing_table(); + + AssertSql( +""" +ALTER TABLE `Customers` ADD `Numbers` longtext CHARACTER SET utf8mb4 NOT NULL DEFAULT ('some numbers'); +"""); + } + + #region ToJson + + public override Task Create_table_with_json_column() + => Assert.ThrowsAsync(() => base.Create_table_with_json_column()); + + public override Task Create_table_with_json_column_explicit_json_column_names() + => Assert.ThrowsAsync(() => base.Create_table_with_json_column_explicit_json_column_names()); + + public override Task Rename_table_with_json_column() + => Assert.ThrowsAsync(() => base.Rename_table_with_json_column()); + + public override Task Add_json_columns_to_existing_table() + => Assert.ThrowsAsync(() => base.Add_json_columns_to_existing_table()); + + public override Task Convert_json_entities_to_regular_owned() + => Assert.ThrowsAsync(() => base.Convert_json_entities_to_regular_owned()); + + public override Task Convert_regular_owned_entities_to_json() + => Assert.ThrowsAsync(() => base.Convert_regular_owned_entities_to_json()); + + public override Task Convert_string_column_to_a_json_column_containing_reference() + => Assert.ThrowsAsync(() => base.Convert_string_column_to_a_json_column_containing_reference()); + + public override Task Convert_string_column_to_a_json_column_containing_required_reference() + => Assert.ThrowsAsync(() => base.Convert_string_column_to_a_json_column_containing_required_reference()); + + public override Task Convert_string_column_to_a_json_column_containing_collection() + => Assert.ThrowsAsync(() => base.Convert_string_column_to_a_json_column_containing_collection()); + + public override Task Drop_json_columns_from_existing_table() + => Assert.ThrowsAsync(() => base.Drop_json_columns_from_existing_table()); + + public override Task Rename_json_column() + => Assert.ThrowsAsync(() => base.Rename_json_column()); + + #endregion ToJson + + [ConditionalFact] + public virtual void Check_all_tests_overridden() + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); + + // The constraint name for a primary key is always PRIMARY in MySQL. + protected override bool AssertConstraintNames + => false; + + // MySQL does not support the concept of schemas. + protected override bool AssertSchemaNames + => false; + + protected virtual string DefaultCollation => ((MySqlTestStore)Fixture.TestStore).DatabaseCollation; + + protected override string NonDefaultCollation + => DefaultCollation == ((MySqlTestStore)Fixture.TestStore).ServerVersion.Value.DefaultUtf8CsCollation + ? ((MySqlTestStore)Fixture.TestStore).ServerVersion.Value.DefaultUtf8CiCollation + : ((MySqlTestStore)Fixture.TestStore).ServerVersion.Value.DefaultUtf8CsCollation; + + protected virtual string NonDefaultCollation2 + => "utf8mb4_german2_ci"; + + protected virtual string DefaultCharSet => ((MySqlTestStore)Fixture.TestStore).DatabaseCharSet; + protected virtual string NonDefaultCharSet => "latin1"; + protected virtual string NonDefaultCharSet2 => "ascii"; + + protected virtual TestHelpers TestHelpers => MySqlTestHelpers.Instance; + + protected virtual Task Test( + Action buildCommonAction, + Action buildSourceAction, + Action buildTargetAction, + Action migrationBuilderAction, + Action asserter, + bool withConventions = true) + { + var services = TestHelpers.CreateContextServices(); + var modelRuntimeInitializer = services.GetRequiredService(); + + // Build the source model, possibly with conventions + var sourceModelBuilder = CreateModelBuilder(withConventions); + buildCommonAction(sourceModelBuilder); + buildSourceAction(sourceModelBuilder); + var preSnapshotSourceModel = modelRuntimeInitializer.Initialize( + (IModel)sourceModelBuilder.Model, designTime: true, validationLogger: null); + + // Round-trip the source model through a snapshot, compiling it and then extracting it back again. + // This simulates the real-world migration flow and can expose errors in snapshot generation + var migrationsCodeGenerator = Fixture.TestHelpers.CreateDesignServiceProvider().GetRequiredService(); + var sourceModelSnapshot = migrationsCodeGenerator.GenerateSnapshot( + modelSnapshotNamespace: null, typeof(DbContext), "MigrationsTestSnapshot", preSnapshotSourceModel); + var sourceModel = BuildModelFromSnapshotSource(sourceModelSnapshot); + + // Build the target model, possibly with conventions + var targetModelBuilder = CreateModelBuilder(withConventions); + buildCommonAction(targetModelBuilder); + buildTargetAction(targetModelBuilder); + var targetModel = modelRuntimeInitializer.Initialize( + (IModel)targetModelBuilder.Model, designTime: true, validationLogger: null); + + var migrationBuilder = new MigrationBuilder(null); + migrationBuilderAction(migrationBuilder); + + return Test(sourceModel, targetModel, migrationBuilder.Operations, asserter); + } + + private ModelBuilder CreateModelBuilder(bool withConventions) + => withConventions ? Fixture.TestHelpers.CreateConventionBuilder() : new ModelBuilder(new ConventionSet()); + + public class MigrationsMySqlFixture : MigrationsFixtureBase { protected override string StoreName => nameof(MigrationsMySqlTest); @@ -1411,8 +2284,7 @@ protected override string StoreName public override DbContextOptionsBuilder AddOptions(DbContextOptionsBuilder builder) { new MySqlDbContextOptionsBuilder(builder) - .SchemaBehavior(MySqlSchemaBehavior.Translate, (schema, table) => $"{schema}_{table}"); - + .SchemaBehavior(MySqlSchemaBehavior.Ignore); return base.AddOptions(builder); } diff --git a/test/EFCore.MySql.FunctionalTests/MySqlComplianceTest.cs b/test/EFCore.MySql.FunctionalTests/MySqlComplianceTest.cs index 65753ad2a..dac7c8a99 100644 --- a/test/EFCore.MySql.FunctionalTests/MySqlComplianceTest.cs +++ b/test/EFCore.MySql.FunctionalTests/MySqlComplianceTest.cs @@ -17,6 +17,13 @@ public class MySqlComplianceTest : RelationalComplianceTestBase typeof(CommandInterceptionTestBase), typeof(NorthwindQueryTaggingQueryTestBase<>), + // TODO: 9.0 + typeof(AdHocComplexTypeQueryTestBase), + typeof(AdHocPrecompiledQueryRelationalTestBase), + typeof(JsonQueryRelationalTestBase<>), + typeof(PrecompiledQueryRelationalTestBase), + typeof(PrecompiledSqlPregenerationQueryRelationalTestBase), + // TODO: Reenable LoggingMySqlTest once its issue has been fixed in EF Core upstream. typeof(LoggingTestBase), typeof(LoggingRelationalTestBase<,>), diff --git a/test/EFCore.MySql.FunctionalTests/MySqlMigrationsSqlGeneratorTest.cs b/test/EFCore.MySql.FunctionalTests/MySqlMigrationsSqlGeneratorTest.cs index c7a97e22c..6d7680612 100644 --- a/test/EFCore.MySql.FunctionalTests/MySqlMigrationsSqlGeneratorTest.cs +++ b/test/EFCore.MySql.FunctionalTests/MySqlMigrationsSqlGeneratorTest.cs @@ -1380,17 +1380,23 @@ public virtual void AlterTableOperation_with_collation_reset() .OldAnnotation(RelationalAnnotationNames.Collation, "latin1_general_ci"); }); + var collationColumnName = AppConfig.ServerVersion.Supports.CollationCharacterSetApplicabilityWithFullCollationNameColumn + ? "FULL_COLLATION_NAME" + : "COLLATION_NAME"; + Assert.Equal( - @"set @__pomelo_TableCharset = ( - SELECT `ccsa`.`CHARACTER_SET_NAME` as `TABLE_CHARACTER_SET` - FROM `INFORMATION_SCHEMA`.`TABLES` as `t` - LEFT JOIN `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`COLLATION_NAME` = `t`.`TABLE_COLLATION` - WHERE `TABLE_SCHEMA` = SCHEMA() AND `TABLE_NAME` = 'IceCreams' AND `TABLE_TYPE` IN ('BASE TABLE', 'VIEW')); +$""" +set @__pomelo_TableCharset = ( +SELECT `ccsa`.`CHARACTER_SET_NAME` as `TABLE_CHARACTER_SET` +FROM `INFORMATION_SCHEMA`.`TABLES` as `t` +LEFT JOIN `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`{collationColumnName}` = `t`.`TABLE_COLLATION` +WHERE `TABLE_SCHEMA` = SCHEMA() AND `TABLE_NAME` = 'IceCreams' AND `TABLE_TYPE` IN ('BASE TABLE', 'VIEW')); SET @__pomelo_SqlExpr = CONCAT('ALTER TABLE `IceCreams` CHARACTER SET = ', @__pomelo_TableCharset, ';'); PREPARE __pomelo_SqlExprExecute FROM @__pomelo_SqlExpr; EXECUTE __pomelo_SqlExprExecute; -DEALLOCATE PREPARE __pomelo_SqlExprExecute;" + EOL, +DEALLOCATE PREPARE __pomelo_SqlExprExecute; +""" + EOL, Sql, ignoreLineEndingDifferences: true); } @@ -1499,17 +1505,23 @@ public virtual void AlterTableOperation_with_charset_reset() .OldAnnotation(MySqlAnnotationNames.CharSet, "latin1"); }); + var collationColumnName = AppConfig.ServerVersion.Supports.CollationCharacterSetApplicabilityWithFullCollationNameColumn + ? "FULL_COLLATION_NAME" + : "COLLATION_NAME"; + Assert.Equal( - @"set @__pomelo_TableCharset = ( - SELECT `ccsa`.`CHARACTER_SET_NAME` as `TABLE_CHARACTER_SET` - FROM `INFORMATION_SCHEMA`.`TABLES` as `t` - LEFT JOIN `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`COLLATION_NAME` = `t`.`TABLE_COLLATION` - WHERE `TABLE_SCHEMA` = SCHEMA() AND `TABLE_NAME` = 'IceCreams' AND `TABLE_TYPE` IN ('BASE TABLE', 'VIEW')); +$""" +set @__pomelo_TableCharset = ( +SELECT `ccsa`.`CHARACTER_SET_NAME` as `TABLE_CHARACTER_SET` +FROM `INFORMATION_SCHEMA`.`TABLES` as `t` +LEFT JOIN `INFORMATION_SCHEMA`.`COLLATION_CHARACTER_SET_APPLICABILITY` as `ccsa` ON `ccsa`.`{collationColumnName}` = `t`.`TABLE_COLLATION` +WHERE `TABLE_SCHEMA` = SCHEMA() AND `TABLE_NAME` = 'IceCreams' AND `TABLE_TYPE` IN ('BASE TABLE', 'VIEW')); SET @__pomelo_SqlExpr = CONCAT('ALTER TABLE `IceCreams` CHARACTER SET = ', @__pomelo_TableCharset, ';'); PREPARE __pomelo_SqlExprExecute FROM @__pomelo_SqlExpr; EXECUTE __pomelo_SqlExprExecute; -DEALLOCATE PREPARE __pomelo_SqlExprExecute;" + EOL, +DEALLOCATE PREPARE __pomelo_SqlExprExecute; +""" + EOL, Sql, ignoreLineEndingDifferences: true); } @@ -1696,7 +1708,6 @@ public virtual void CreateSequenceOperation_with_minValue_and_maxValue() [SupportedServerVersionCondition(nameof(ServerVersionSupport.Sequences))] public virtual void CreateSequenceOperation_without_minValue_and_maxValue() { - Generate( new CreateSequenceOperation { @@ -1707,7 +1718,7 @@ public virtual void CreateSequenceOperation_without_minValue_and_maxValue() }); Assert.Equal( - @"CREATE SEQUENCE `MySequence` START WITH 1 INCREMENT BY 1 NO MINVALUE NO MAXVALUE NOCYCLE;" + EOL, + @"CREATE SEQUENCE `MySequence` START WITH 1 INCREMENT BY 1 NOCYCLE;" + EOL, Sql, ignoreLineEndingDifferences: true); } diff --git a/test/EFCore.MySql.FunctionalTests/OptimisticConcurrencyMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/OptimisticConcurrencyMySqlTest.cs index ee81309c2..a32a39a0e 100644 --- a/test/EFCore.MySql.FunctionalTests/OptimisticConcurrencyMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/OptimisticConcurrencyMySqlTest.cs @@ -1,9 +1,7 @@ -using System; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Storage; -using Microsoft.EntityFrameworkCore.TestModels.ConcurrencyModel; using Xunit; namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests @@ -18,19 +16,6 @@ public OptimisticConcurrencyMySqlTest(F1MySqlFixture fixture) protected override void UseTransaction(DatabaseFacade facade, IDbContextTransaction transaction) => facade.UseTransaction(transaction.GetDbTransaction()); - protected override Task ConcurrencyTestAsync( - Action storeChange, Action clientChange, - Action resolver, Action validator) - { - return base.ConcurrencyTestAsync(c => - { - storeChange(c); - // CHECK: Is this still/really needed? - // Need to wait to make CURRENT_TIMESTAMP return different values reliably - Task.Delay(100); - }, clientChange, resolver, validator); - } - [ConditionalFact(Skip = "#588")] public override Task Updating_then_deleting_the_same_entity_results_in_DbUpdateConcurrencyException_which_can_be_resolved_with_store_values() { diff --git a/test/EFCore.MySql.FunctionalTests/ProxyGraphUpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/ProxyGraphUpdatesMySqlTest.cs index 31c13a57e..37fd67a06 100644 --- a/test/EFCore.MySql.FunctionalTests/ProxyGraphUpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/ProxyGraphUpdatesMySqlTest.cs @@ -1,4 +1,5 @@ -using Microsoft.EntityFrameworkCore; +using System.Threading.Tasks; +using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.TestUtilities; @@ -63,9 +64,8 @@ public ChangeTracking(ProxyGraphUpdatesWithChangeTrackingMySqlFixture fixture) } // Needs lazy loading - public override void Save_two_entity_cycle_with_lazy_loading() - { - } + public override Task Save_two_entity_cycle_with_lazy_loading() + => Task.CompletedTask; protected override bool DoesLazyLoading => false; diff --git a/test/EFCore.MySql.FunctionalTests/Query/AdHocJsonQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/AdHocJsonQueryMySqlTest.cs index fd8349a93..a9a14d8af 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/AdHocJsonQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/AdHocJsonQueryMySqlTest.cs @@ -1,9 +1,14 @@ using System; +using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Diagnostics; +using Microsoft.EntityFrameworkCore.Diagnostics.Internal; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestUtilities; +using MySqlConnector; +using Pomelo.EntityFrameworkCore.MySql.Diagnostics.Internal; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Xunit; @@ -15,7 +20,7 @@ internal class AdHocJsonQueryMySqlTest : AdHocJsonQueryTestBase protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; - protected override void Seed29219(MyContext29219 ctx) + protected override async Task Seed29219(DbContext ctx) { var entity1 = new MyEntity29219 { @@ -23,9 +28,9 @@ protected override void Seed29219(MyContext29219 ctx) Reference = new MyJsonEntity29219 { NonNullableScalar = 10, NullableScalar = 11 }, Collection = [ - new() { NonNullableScalar = 100, NullableScalar = 101 }, - new() { NonNullableScalar = 200, NullableScalar = 201 }, - new() { NonNullableScalar = 300, NullableScalar = null } + new MyJsonEntity29219 { NonNullableScalar = 100, NullableScalar = 101 }, + new MyJsonEntity29219 { NonNullableScalar = 200, NullableScalar = 201 }, + new MyJsonEntity29219 { NonNullableScalar = 300, NullableScalar = null } ] }; @@ -33,59 +38,66 @@ protected override void Seed29219(MyContext29219 ctx) { Id = 2, Reference = new MyJsonEntity29219 { NonNullableScalar = 20, NullableScalar = null }, - Collection = [new() { NonNullableScalar = 1001, NullableScalar = null }] + Collection = [new MyJsonEntity29219 { NonNullableScalar = 1001, NullableScalar = null }] }; - ctx.Entities.AddRange(entity1, entity2); - ctx.SaveChanges(); + ctx.AddRange(entity1, entity2); + await ctx.SaveChangesAsync(); - ctx.Database.ExecuteSqlRaw( - """ + await ctx.Database.ExecuteSqlAsync( + $$""" INSERT INTO `Entities` (`Id`, `Reference`, `Collection`) -VALUES(3, '{{ "NonNullableScalar" : 30 }}', '[{{ "NonNullableScalar" : 10001 }}]') +VALUES(3, N'{ "NonNullableScalar" : 30 }', N'[{ "NonNullableScalar" : 10001 }]') """); } - protected override void Seed30028(MyContext30028 ctx) + protected override async Task Seed30028(DbContext ctx) { // complete - ctx.Database.ExecuteSqlRaw( - """ + await ctx.Database.ExecuteSqlAsync( + $$$$""" INSERT INTO `Entities` (`Id`, `Json`) VALUES( 1, -'{{"RootName":"e1","Collection":[{{"BranchName":"e1 c1","Nested":{{"LeafName":"e1 c1 l"}}}},{{"BranchName":"e1 c2","Nested":{{"LeafName":"e1 c2 l"}}}}],"OptionalReference":{{"BranchName":"e1 or","Nested":{{"LeafName":"e1 or l"}}}},"RequiredReference":{{"BranchName":"e1 rr","Nested":{{"LeafName":"e1 rr l"}}}}}}') +N'{"RootName":"e1","Collection":[{"BranchName":"e1 c1","Nested":{"LeafName":"e1 c1 l"}},{"BranchName":"e1 c2","Nested":{"LeafName":"e1 c2 l"}}],"OptionalReference":{"BranchName":"e1 or","Nested":{"LeafName":"e1 or l"}},"RequiredReference":{"BranchName":"e1 rr","Nested":{"LeafName":"e1 rr l"}}}') """); // missing collection - ctx.Database.ExecuteSqlRaw( - """ + await ctx.Database.ExecuteSqlAsync( + $$$$""" INSERT INTO `Entities` (`Id`, `Json`) VALUES( 2, -'{{"RootName":"e2","OptionalReference":{{"BranchName":"e2 or","Nested":{{"LeafName":"e2 or l"}}}},"RequiredReference":{{"BranchName":"e2 rr","Nested":{{"LeafName":"e2 rr l"}}}}}}') +N'{"RootName":"e2","OptionalReference":{"BranchName":"e2 or","Nested":{"LeafName":"e2 or l"}},"RequiredReference":{"BranchName":"e2 rr","Nested":{"LeafName":"e2 rr l"}}}') """); // missing optional reference - ctx.Database.ExecuteSqlRaw( - """ + await ctx.Database.ExecuteSqlAsync( + $$$$""" INSERT INTO `Entities` (`Id`, `Json`) VALUES( 3, -'{{"RootName":"e3","Collection":[{{"BranchName":"e3 c1","Nested":{{"LeafName":"e3 c1 l"}}}},{{"BranchName":"e3 c2","Nested":{{"LeafName":"e3 c2 l"}}}}],"RequiredReference":{{"BranchName":"e3 rr","Nested":{{"LeafName":"e3 rr l"}}}}}}') +N'{"RootName":"e3","Collection":[{"BranchName":"e3 c1","Nested":{"LeafName":"e3 c1 l"}},{"BranchName":"e3 c2","Nested":{"LeafName":"e3 c2 l"}}],"RequiredReference":{"BranchName":"e3 rr","Nested":{"LeafName":"e3 rr l"}}}') """); // missing required reference - ctx.Database.ExecuteSqlRaw( - """ + await ctx.Database.ExecuteSqlAsync( + $$$$""" INSERT INTO `Entities` (`Id`, `Json`) VALUES( 4, -'{{"RootName":"e4","Collection":[{{"BranchName":"e4 c1","Nested":{{"LeafName":"e4 c1 l"}}}},{{"BranchName":"e4 c2","Nested":{{"LeafName":"e4 c2 l"}}}}],"OptionalReference":{{"BranchName":"e4 or","Nested":{{"LeafName":"e4 or l"}}}}}}') +N'{"RootName":"e4","Collection":[{"BranchName":"e4 c1","Nested":{"LeafName":"e4 c1 l"}},{"BranchName":"e4 c2","Nested":{"LeafName":"e4 c2 l"}}],"OptionalReference":{"BranchName":"e4 or","Nested":{"LeafName":"e4 or l"}}}') """); } - protected override void SeedArrayOfPrimitives(MyContextArrayOfPrimitives ctx) + protected override Task Seed33046(DbContext ctx) + => ctx.Database.ExecuteSqlAsync( + $$""" +INSERT INTO `Reviews` (`Rounds`, `Id`) +VALUES(N'[{"RoundNumber":11,"SubRounds":[{"SubRoundNumber":111},{"SubRoundNumber":112}]}]', 1) +"""); + + protected override Task SeedArrayOfPrimitives(DbContext ctx) { var entity1 = new MyEntityArrayOfPrimitives { @@ -102,8 +114,8 @@ protected override void SeedArrayOfPrimitives(MyContextArrayOfPrimitives ctx) }, Collection = [ - new() { IntArray = [111, 112, 113], ListOfString = ["Foo11", "Bar11"] }, - new() { IntArray = [211, 212, 213], ListOfString = ["Foo12", "Bar12"] } + new MyJsonEntityArrayOfPrimitives { IntArray = [111, 112, 113], ListOfString = ["Foo11", "Bar11"] }, + new MyJsonEntityArrayOfPrimitives { IntArray = [211, 212, 213], ListOfString = ["Foo12", "Bar12"] } ] }; @@ -122,151 +134,263 @@ protected override void SeedArrayOfPrimitives(MyContextArrayOfPrimitives ctx) }, Collection = [ - new() { IntArray = [110, 120, 130], ListOfString = ["A1", "Z1"] }, - new() { IntArray = [210, 220, 230], ListOfString = ["A2", "Z2"] } + new MyJsonEntityArrayOfPrimitives { IntArray = [110, 120, 130], ListOfString = ["A1", "Z1"] }, + new MyJsonEntityArrayOfPrimitives { IntArray = [210, 220, 230], ListOfString = ["A2", "Z2"] } ] }; - ctx.Entities.AddRange(entity1, entity2); - ctx.SaveChanges(); + ctx.AddRange(entity1, entity2); + return ctx.SaveChangesAsync(); } - protected override void SeedJunkInJson(MyContextJunkInJson ctx) - => ctx.Database.ExecuteSqlRaw( - """ + protected override Task SeedJunkInJson(DbContext ctx) + => ctx.Database.ExecuteSqlAsync( + $$$$""" INSERT INTO `Entities` (`Collection`, `CollectionWithCtor`, `Reference`, `ReferenceWithCtor`, `Id`) VALUES( -'[{{"JunkReference":{{"Something":"SomeValue" }},"Name":"c11","JunkProperty1":50,"Number":11.5,"JunkCollection1":[],"JunkCollection2":[{{"Foo":"junk value"}}],"NestedCollection":[{{"DoB":"2002-04-01T00:00:00","DummyProp":"Dummy value"}},{{"DoB":"2002-04-02T00:00:00","DummyReference":{{"Foo":5}}}}],"NestedReference":{{"DoB":"2002-03-01T00:00:00"}}}},{{"Name":"c12","Number":12.5,"NestedCollection":[{{"DoB":"2002-06-01T00:00:00"}},{{"DoB":"2002-06-02T00:00:00"}}],"NestedDummy":59,"NestedReference":{{"DoB":"2002-05-01T00:00:00"}}}}]', -'[{{"MyBool":true,"Name":"c11 ctor","JunkReference":{{"Something":"SomeValue","JunkCollection":[{{"Foo":"junk value"}}]}},"NestedCollection":[{{"DoB":"2002-08-01T00:00:00"}},{{"DoB":"2002-08-02T00:00:00"}}],"NestedReference":{{"DoB":"2002-07-01T00:00:00"}}}},{{"MyBool":false,"Name":"c12 ctor","NestedCollection":[{{"DoB":"2002-10-01T00:00:00"}},{{"DoB":"2002-10-02T00:00:00"}}],"JunkCollection":[{{"Foo":"junk value"}}],"NestedReference":{{"DoB":"2002-09-01T00:00:00"}}}}]', -'{{"Name":"r1","JunkCollection":[{{"Foo":"junk value"}}],"JunkReference":{{"Something":"SomeValue" }},"Number":1.5,"NestedCollection":[{{"DoB":"2000-02-01T00:00:00","JunkReference":{{"Something":"SomeValue"}}}},{{"DoB":"2000-02-02T00:00:00"}}],"NestedReference":{{"DoB":"2000-01-01T00:00:00"}}}}', -'{{"MyBool":true,"JunkCollection":[{{"Foo":"junk value"}}],"Name":"r1 ctor","JunkReference":{{"Something":"SomeValue" }},"NestedCollection":[{{"DoB":"2001-02-01T00:00:00"}},{{"DoB":"2001-02-02T00:00:00"}}],"NestedReference":{{"JunkCollection":[{{"Foo":"junk value"}}],"DoB":"2001-01-01T00:00:00"}}}}', +N'[{"JunkReference":{"Something":"SomeValue" },"Name":"c11","JunkProperty1":50,"Number":11.5,"JunkCollection1":[],"JunkCollection2":[{"Foo":"junk value"}],"NestedCollection":[{"DoB":"2002-04-01T00:00:00","DummyProp":"Dummy value"},{"DoB":"2002-04-02T00:00:00","DummyReference":{"Foo":5}}],"NestedReference":{"DoB":"2002-03-01T00:00:00"}},{"Name":"c12","Number":12.5,"NestedCollection":[{"DoB":"2002-06-01T00:00:00"},{"DoB":"2002-06-02T00:00:00"}],"NestedDummy":59,"NestedReference":{"DoB":"2002-05-01T00:00:00"}}]', +N'[{"MyBool":true,"Name":"c11 ctor","JunkReference":{"Something":"SomeValue","JunkCollection":[{"Foo":"junk value"}]},"NestedCollection":[{"DoB":"2002-08-01T00:00:00"},{"DoB":"2002-08-02T00:00:00"}],"NestedReference":{"DoB":"2002-07-01T00:00:00"}},{"MyBool":false,"Name":"c12 ctor","NestedCollection":[{"DoB":"2002-10-01T00:00:00"},{"DoB":"2002-10-02T00:00:00"}],"JunkCollection":[{"Foo":"junk value"}],"NestedReference":{"DoB":"2002-09-01T00:00:00"}}]', +N'{"Name":"r1","JunkCollection":[{"Foo":"junk value"}],"JunkReference":{"Something":"SomeValue" },"Number":1.5,"NestedCollection":[{"DoB":"2000-02-01T00:00:00","JunkReference":{"Something":"SomeValue"}},{"DoB":"2000-02-02T00:00:00"}],"NestedReference":{"DoB":"2000-01-01T00:00:00"}}', +N'{"MyBool":true,"JunkCollection":[{"Foo":"junk value"}],"Name":"r1 ctor","JunkReference":{"Something":"SomeValue" },"NestedCollection":[{"DoB":"2001-02-01T00:00:00"},{"DoB":"2001-02-02T00:00:00"}],"NestedReference":{"JunkCollection":[{"Foo":"junk value"}],"DoB":"2001-01-01T00:00:00"}}', 1) """); - protected override void SeedTrickyBuffering(MyContextTrickyBuffering ctx) - => ctx.Database.ExecuteSqlRaw( - """ + protected override Task SeedTrickyBuffering(DbContext ctx) + => ctx.Database.ExecuteSqlAsync( + $$$""" INSERT INTO `Entities` (`Reference`, `Id`) VALUES( -'{{"Name": "r1", "Number": 7, "JunkReference":{{"Something": "SomeValue" }}, "JunkCollection": [{{"Foo": "junk value"}}], "NestedReference": {{"DoB": "2000-01-01T00:00:00Z"}}, "NestedCollection": [{{"DoB": "2000-02-01T00:00:00Z", "JunkReference": {{"Something": "SomeValue"}}}}, {{"DoB": "2000-02-02T00:00:00Z"}}]}}',1) +N'{"Name": "r1", "Number": 7, "JunkReference":{"Something": "SomeValue" }, "JunkCollection": [{"Foo": "junk value"}], "NestedReference": {"DoB": "2000-01-01T00:00:00"}, "NestedCollection": [{"DoB": "2000-02-01T00:00:00", "JunkReference": {"Something": "SomeValue"}}, {"DoB": "2000-02-02T00:00:00"}]}',1) """); - protected override void SeedShadowProperties(MyContextShadowProperties ctx) - => ctx.Database.ExecuteSqlRaw( - """ + protected override Task SeedShadowProperties(DbContext ctx) + => ctx.Database.ExecuteSqlAsync( + $$""" INSERT INTO `Entities` (`Collection`, `CollectionWithCtor`, `Reference`, `ReferenceWithCtor`, `Id`, `Name`) VALUES( -'[{{"Name":"e1_c1","ShadowDouble":5.5}},{{"ShadowDouble":20.5,"Name":"e1_c2"}}]', -'[{{"Name":"e1_c1 ctor","ShadowNullableByte":6}},{{"ShadowNullableByte":null,"Name":"e1_c2 ctor"}}]', -'{{"Name":"e1_r", "ShadowString":"Foo"}}', -'{{"ShadowInt":143,"Name":"e1_r ctor"}}', +N'[{"Name":"e1_c1","ShadowDouble":5.5},{"ShadowDouble":20.5,"Name":"e1_c2"}]', +N'[{"Name":"e1_c1 ctor","ShadowNullableByte":6},{"ShadowNullableByte":null,"Name":"e1_c2 ctor"}]', +N'{"Name":"e1_r", "ShadowString":"Foo"}', +N'{"ShadowInt":143,"Name":"e1_r ctor"}', 1, -'e1') +N'e1') """); - protected override void SeedNotICollection(MyContextNotICollection ctx) + protected override async Task SeedNotICollection(DbContext ctx) { - ctx.Database.ExecuteSqlRaw( - """ + await ctx.Database.ExecuteSqlAsync( + $$""" INSERT INTO `Entities` (`Json`, `Id`) VALUES( -'{{"Collection":[{{"Bar":11,"Foo":"c11"}},{{"Bar":12,"Foo":"c12"}},{{"Bar":13,"Foo":"c13"}}]}}', +N'{"Collection":[{"Bar":11,"Foo":"c11"},{"Bar":12,"Foo":"c12"},{"Bar":13,"Foo":"c13"}]}', 1) """); - ctx.Database.ExecuteSqlRaw( - """ + await ctx.Database.ExecuteSqlAsync( + $$$""" INSERT INTO `Entities` (`Json`, `Id`) VALUES( -'{{"Collection":[{{"Bar":21,"Foo":"c21"}},{{"Bar":22,"Foo":"c22"}}]}}', +N'{"Collection":[{"Bar":21,"Foo":"c21"},{"Bar":22,"Foo":"c22"}]}', 2) """); } - [ConditionalTheory, MemberData(nameof(IsAsyncData))] - public virtual async Task Json_predicate_on_bytea(bool async) + #region EnumLegacyValues + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Read_enum_property_with_legacy_values(bool async) { - var contextFactory = await InitializeAsync( - seed: context => - { - context.Entities.AddRange( - new TypesContainerEntity { JsonEntity = new TypesJsonEntity { Bytea = [1, 2, 3] } }, - new TypesContainerEntity { JsonEntity = new TypesJsonEntity { Bytea = [1, 2, 4] } }); - context.SaveChanges(); - }); + var contextFactory = await InitializeAsync( + onModelCreating: BuildModelEnumLegacyValues, + onConfiguring: b => b.ConfigureWarnings(ConfigureWarnings), + seed: SeedEnumLegacyValues); using (var context = contextFactory.CreateContext()) { - var query = context.Entities.Where(x => x.JsonEntity.Bytea == new byte[] { 1, 2, 4 }); + var query = context.Set().Select( + x => new + { + x.Reference.IntEnum, + x.Reference.ByteEnum, + x.Reference.LongEnum, + x.Reference.NullableEnum + }); + + var exception = async + ? await (Assert.ThrowsAsync(() => query.ToListAsync())) + : Assert.Throws(() => query.ToList()); + + // Conversion failed when converting the nvarchar value '...' to data type int + Assert.Equal(245, exception.Number); + } + } - var result = async - ? await query.SingleAsync() - : query.Single(); + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Read_json_entity_with_enum_properties_with_legacy_values(bool async) + { + var contextFactory = await InitializeAsync( + onModelCreating: BuildModelEnumLegacyValues, + onConfiguring: b => b.ConfigureWarnings(ConfigureWarnings), + seed: SeedEnumLegacyValues, + shouldLogCategory: c => c == DbLoggerCategory.Query.Name); - Assert.Equal(2, result.Id); + using (var context = contextFactory.CreateContext()) + { + var query = context.Set().Select(x => x.Reference).AsNoTracking(); - AssertSql( - """ -SELECT e.`Id`, e.`JsonEntity` -FROM `Entities` AS e -WHERE (decode(e.`JsonEntity` ->> 'Bytea', 'base64')) = BYTEA E'\\x010204' -LIMIT 2 -"""); + var result = async + ? await query.ToListAsync() + : query.ToList(); + + Assert.Equal(1, result.Count); + Assert.Equal(ByteEnumLegacyValues.Redmond, result[0].ByteEnum); + Assert.Equal(IntEnumLegacyValues.Foo, result[0].IntEnum); + Assert.Equal(LongEnumLegacyValues.Three, result[0].LongEnum); + Assert.Equal(ULongEnumLegacyValues.Three, result[0].ULongEnum); + Assert.Equal(IntEnumLegacyValues.Bar, result[0].NullableEnum); } + + var testLogger = new TestLogger(); + Assert.Single( + ListLoggerFactory.Log.Where( + l => l.Message == CoreResources.LogStringEnumValueInJson(testLogger).GenerateMessage(nameof(ByteEnumLegacyValues)))); + Assert.Single( + ListLoggerFactory.Log.Where( + l => l.Message == CoreResources.LogStringEnumValueInJson(testLogger).GenerateMessage(nameof(IntEnumLegacyValues)))); + Assert.Single( + ListLoggerFactory.Log.Where( + l => l.Message == CoreResources.LogStringEnumValueInJson(testLogger).GenerateMessage(nameof(LongEnumLegacyValues)))); + Assert.Single( + ListLoggerFactory.Log.Where( + l => l.Message == CoreResources.LogStringEnumValueInJson(testLogger).GenerateMessage(nameof(ULongEnumLegacyValues)))); } - [ConditionalTheory, MemberData(nameof(IsAsyncData))] - public virtual async Task Json_predicate_on_interval(bool async) + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public virtual async Task Read_json_entity_collection_with_enum_properties_with_legacy_values(bool async) { - var contextFactory = await InitializeAsync( - seed: context => - { - context.Entities.AddRange( - new TypesContainerEntity { JsonEntity = new TypesJsonEntity { Interval = new TimeSpan(1, 2, 3, 4, 123, 456) } }, - new TypesContainerEntity { JsonEntity = new TypesJsonEntity { Interval = new TimeSpan(2, 2, 3, 4, 123, 456) } }); - context.SaveChanges(); - }); + var contextFactory = await InitializeAsync( + onModelCreating: BuildModelEnumLegacyValues, + onConfiguring: b => b.ConfigureWarnings(ConfigureWarnings), + seed: SeedEnumLegacyValues, + shouldLogCategory: c => c == DbLoggerCategory.Query.Name); using (var context = contextFactory.CreateContext()) { - var query = context.Entities.Where(x => x.JsonEntity.Interval == new TimeSpan(2, 2, 3, 4, 123, 456)); + var query = context.Set().Select(x => x.Collection).AsNoTracking(); var result = async - ? await query.SingleAsync() - : query.Single(); + ? await query.ToListAsync() + : query.ToList(); + + Assert.Equal(1, result.Count); + Assert.Equal(2, result[0].Count); + Assert.Equal(ByteEnumLegacyValues.Bellevue, result[0][0].ByteEnum); + Assert.Equal(IntEnumLegacyValues.Foo, result[0][0].IntEnum); + Assert.Equal(LongEnumLegacyValues.One, result[0][0].LongEnum); + Assert.Equal(ULongEnumLegacyValues.One, result[0][0].ULongEnum); + Assert.Equal(IntEnumLegacyValues.Bar, result[0][0].NullableEnum); + Assert.Equal(ByteEnumLegacyValues.Seattle, result[0][1].ByteEnum); + Assert.Equal(IntEnumLegacyValues.Baz, result[0][1].IntEnum); + Assert.Equal(LongEnumLegacyValues.Two, result[0][1].LongEnum); + Assert.Equal(ULongEnumLegacyValues.Two, result[0][1].ULongEnum); + Assert.Null(result[0][1].NullableEnum); + } - Assert.Equal(2, result.Id); + var testLogger = new TestLogger(); + Assert.Single( + ListLoggerFactory.Log.Where( + l => l.Message == CoreResources.LogStringEnumValueInJson(testLogger).GenerateMessage(nameof(ByteEnumLegacyValues)))); + Assert.Single( + ListLoggerFactory.Log.Where( + l => l.Message == CoreResources.LogStringEnumValueInJson(testLogger).GenerateMessage(nameof(IntEnumLegacyValues)))); + Assert.Single( + ListLoggerFactory.Log.Where( + l => l.Message == CoreResources.LogStringEnumValueInJson(testLogger).GenerateMessage(nameof(LongEnumLegacyValues)))); + Assert.Single( + ListLoggerFactory.Log.Where( + l => l.Message == CoreResources.LogStringEnumValueInJson(testLogger).GenerateMessage(nameof(ULongEnumLegacyValues)))); + } - AssertSql( - """ -SELECT e.`Id`, e.`JsonEntity` -FROM `Entities` AS e -WHERE (CAST(e.`JsonEntity` ->> 'Interval' AS interval)) = INTERVAL '2 02:03:04.123456' -LIMIT 2 + private Task SeedEnumLegacyValues(DbContext ctx) + => ctx.Database.ExecuteSqlAsync( + $$""" +INSERT INTO `Entities` (`Collection`, `Reference`, `Id`, `Name`) +VALUES( +N'[{"ByteEnum":"Bellevue","IntEnum":"Foo","LongEnum":"One","ULongEnum":"One","Name":"e1_c1","NullableEnum":"Bar"},{"ByteEnum":"Seattle","IntEnum":"Baz","LongEnum":"Two","ULongEnum":"Two","Name":"e1_c2","NullableEnum":null}]', +N'{"ByteEnum":"Redmond","IntEnum":"Foo","LongEnum":"Three","ULongEnum":"Three","Name":"e1_r","NullableEnum":"Bar"}', +1, +N'e1') """); - } + + protected virtual void BuildModelEnumLegacyValues(ModelBuilder modelBuilder) + => modelBuilder.Entity( + b => + { + b.ToTable("Entities"); + b.Property(x => x.Id).ValueGeneratedNever(); + b.OwnsOne(x => x.Reference, b => b.ToJson().HasColumnType(JsonColumnType)); + b.OwnsMany(x => x.Collection, b => b.ToJson().HasColumnType(JsonColumnType)); + }); + + private class MyEntityEnumLegacyValues + { + public int Id { get; set; } + public string Name { get; set; } + + public MyJsonEntityEnumLegacyValues Reference { get; set; } + public List Collection { get; set; } } - protected class TypesDbContext(DbContextOptions options) : DbContext(options) + private class MyJsonEntityEnumLegacyValues { - public DbSet Entities { get; set; } + public string Name { get; set; } + + // ReSharper disable once UnusedAutoPropertyAccessor.Local + public IntEnumLegacyValues IntEnum { get; set; } + + // ReSharper disable once UnusedAutoPropertyAccessor.Local + public ByteEnumLegacyValues ByteEnum { get; set; } - protected override void OnModelCreating(ModelBuilder modelBuilder) - => modelBuilder.Entity().OwnsOne(b => b.JsonEntity).ToJson(); + // ReSharper disable once UnusedAutoPropertyAccessor.Local + public LongEnumLegacyValues LongEnum { get; set; } + + // ReSharper disable once UnusedAutoPropertyAccessor.Local + public ULongEnumLegacyValues ULongEnum { get; set; } + + // ReSharper disable once UnusedAutoPropertyAccessor.Local + public IntEnumLegacyValues? NullableEnum { get; set; } } - public class TypesContainerEntity + private enum IntEnumLegacyValues { - public int Id { get; set; } - public TypesJsonEntity JsonEntity { get; set; } + Foo = int.MinValue, + Bar, + Baz = int.MaxValue, + } + + private enum ByteEnumLegacyValues : byte + { + Seattle, + Redmond, + Bellevue = 255, + } + + private enum LongEnumLegacyValues : long + { + One = long.MinValue, + Two = 1, + Three = long.MaxValue, } - public class TypesJsonEntity + private enum ULongEnumLegacyValues : ulong { - public byte[] Bytea { get; set; } - public TimeSpan Interval { get; set; } + One = ulong.MinValue, + Two = 1, + Three = ulong.MaxValue, } - protected void AssertSql(params string[] expected) - => TestSqlLoggerFactory.AssertBaseline(expected); + #endregion } diff --git a/test/EFCore.MySql.FunctionalTests/Query/AdHocMiscellaneousQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/AdHocMiscellaneousQueryMySqlTest.cs index 2235fb2a9..0a1781252 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/AdHocMiscellaneousQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/AdHocMiscellaneousQueryMySqlTest.cs @@ -13,8 +13,8 @@ public class AdHocMiscellaneousQueryMySqlTest : AdHocMiscellaneousQueryRelationa protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; - protected override void Seed2951(Context2951 context) - => context.Database.ExecuteSqlRaw( + protected override Task Seed2951(Context2951 context) + => context.Database.ExecuteSqlRawAsync( """ CREATE TABLE `ZeroKey` (`Id` int); INSERT INTO `ZeroKey` VALUES (NULL) diff --git a/test/EFCore.MySql.FunctionalTests/Query/CaseSensitiveNorthwindQueryMySqlFixture.cs b/test/EFCore.MySql.FunctionalTests/Query/CaseSensitiveNorthwindQueryMySqlFixture.cs index 4ccce05bf..4db2a8247 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/CaseSensitiveNorthwindQueryMySqlFixture.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/CaseSensitiveNorthwindQueryMySqlFixture.cs @@ -1,21 +1,13 @@ -using Microsoft.EntityFrameworkCore; -using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.Query { public class CaseSensitiveNorthwindQueryMySqlFixture : NorthwindQueryMySqlFixture - where TModelCustomizer : IModelCustomizer, new() + where TModelCustomizer : ITestModelCustomizer, new() { protected override string StoreName => "NorthwindCs"; protected override ITestStoreFactory TestStoreFactory => MySqlNorthwindTestStoreFactory.InstanceCs; - - public override DbContextOptionsBuilder AddOptions(DbContextOptionsBuilder builder) - { - var optionsBuilder = base.AddOptions(builder); - new MySqlDbContextOptionsBuilder(optionsBuilder).EnableStringComparisonTranslations(); - return optionsBuilder; - } } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/CaseSensitiveWithStringComparisonNorthwindQueryMySqlFixture.cs b/test/EFCore.MySql.FunctionalTests/Query/CaseSensitiveWithStringComparisonNorthwindQueryMySqlFixture.cs new file mode 100644 index 000000000..b766474cb --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Query/CaseSensitiveWithStringComparisonNorthwindQueryMySqlFixture.cs @@ -0,0 +1,15 @@ +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; + +namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.Query; + +public class CaseSensitiveWithStringComparisonNorthwindQueryMySqlFixture : CaseSensitiveNorthwindQueryMySqlFixture + where TModelCustomizer : ITestModelCustomizer, new() +{ + public override DbContextOptionsBuilder AddOptions(DbContextOptionsBuilder builder) + { + var optionsBuilder = base.AddOptions(builder); + new MySqlDbContextOptionsBuilder(optionsBuilder).EnableStringComparisonTranslations(); + return optionsBuilder; + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsCollectionsSplitQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsCollectionsSplitQueryMySqlTest.cs index 23f47e655..6d0841297 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsCollectionsSplitQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsCollectionsSplitQueryMySqlTest.cs @@ -2426,13 +2426,10 @@ public override async Task Include_collection_with_groupby_in_subquery_and_filte """ SELECT `l3`.`Id`, `l3`.`Date`, `l3`.`Name`, `l3`.`OneToMany_Optional_Self_Inverse1Id`, `l3`.`OneToMany_Required_Self_Inverse1Id`, `l3`.`OneToOne_Optional_Self1Id`, `l1`.`Name` FROM ( - SELECT `l10`.`Name` - FROM ( - SELECT `l`.`Name`, (`l`.`Name` <> 'Foo') OR `l`.`Name` IS NULL AS `c` - FROM `LevelOne` AS `l` - GROUP BY `l`.`Name`, `c` - HAVING `c` - ) AS `l10` + SELECT `l`.`Name`, (`l`.`Name` <> 'Foo') OR `l`.`Name` IS NULL AS `c` + FROM `LevelOne` AS `l` + GROUP BY `l`.`Name`, `c` + HAVING `c` ) AS `l1` LEFT JOIN ( SELECT `l2`.`Id`, `l2`.`Date`, `l2`.`Name`, `l2`.`OneToMany_Optional_Self_Inverse1Id`, `l2`.`OneToMany_Required_Self_Inverse1Id`, `l2`.`OneToOne_Optional_Self1Id` @@ -2448,13 +2445,10 @@ LEFT JOIN ( """ SELECT `l6`.`Id`, `l6`.`Date`, `l6`.`Level1_Optional_Id`, `l6`.`Level1_Required_Id`, `l6`.`Name`, `l6`.`OneToMany_Optional_Inverse2Id`, `l6`.`OneToMany_Optional_Self_Inverse2Id`, `l6`.`OneToMany_Required_Inverse2Id`, `l6`.`OneToMany_Required_Self_Inverse2Id`, `l6`.`OneToOne_Optional_PK_Inverse2Id`, `l6`.`OneToOne_Optional_Self2Id`, `l7`.`Name`, `l9`.`Id` FROM ( - SELECT `l11`.`Name` - FROM ( - SELECT `l`.`Name`, (`l`.`Name` <> 'Foo') OR `l`.`Name` IS NULL AS `c` - FROM `LevelOne` AS `l` - GROUP BY `l`.`Name`, `c` - HAVING `c` - ) AS `l11` + SELECT `l`.`Name`, (`l`.`Name` <> 'Foo') OR `l`.`Name` IS NULL AS `c` + FROM `LevelOne` AS `l` + GROUP BY `l`.`Name`, `c` + HAVING `c` ) AS `l7` LEFT JOIN ( SELECT `l8`.`Id`, `l8`.`Name` diff --git a/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsQueryMySqlTest.cs index 5c46ba16d..6699e4446 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsQueryMySqlTest.cs @@ -21,9 +21,6 @@ public ComplexNavigationsQueryMySqlTest(ComplexNavigationsQueryMySqlFixture fixt //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - [SupportedServerVersionCondition(nameof(ServerVersionSupport.OuterReferenceInMultiLevelSubquery))] public override Task Contains_with_subquery_optional_navigation_and_constant_item(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsSharedTypeQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsSharedTypeQueryMySqlTest.cs index 3c2954f2b..f8af953af 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsSharedTypeQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/ComplexNavigationsSharedTypeQueryMySqlTest.cs @@ -33,26 +33,6 @@ public override Task Contains_with_subquery_optional_navigation_and_constant_ite return base.Contains_with_subquery_optional_navigation_and_constant_item(async); } - public override Task Distinct_take_without_orderby(bool async) - { - return AssertQuery( - async, - ss => from l1 in ss.Set() - where l1.Id < 3 - select (from l3 in ss.Set() - select l3).Distinct().OrderBy(e => e.Id).Take(1).FirstOrDefault().Name); // Apply OrderBy before Skip - } - - public override Task Distinct_skip_without_orderby(bool async) - { - return AssertQuery( - async, - ss => from l1 in ss.Set() - where l1.Id < 3 - select (from l3 in ss.Set() - select l3).Distinct().OrderBy(e => e.Id).Skip(1).FirstOrDefault().Name); // Apply OrderBy before Skip - } - public override async Task SelectMany_subquery_with_custom_projection(bool async) { // TODO: Fix test in EF Core upstream. diff --git a/test/EFCore.MySql.FunctionalTests/Query/ComplexTypeQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/ComplexTypeQueryMySqlTest.cs index c7e021390..5be666351 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/ComplexTypeQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/ComplexTypeQueryMySqlTest.cs @@ -238,12 +238,12 @@ public override async Task Complex_type_equals_parameter(bool async) @__entity_equality_address_0_AddressLine1='804 S. Lakeshore Road' (Size = 4000) @__entity_equality_address_0_Tags='["foo","bar"]' (Size = 4000) @__entity_equality_address_0_ZipCode='38654' (Nullable = true) -@__entity_equality_address_0_Code='US' (Size = 4000) -@__entity_equality_address_0_FullName='United States' (Size = 4000) +@__entity_equality_address_0_Country_Code='US' (Size = 4000) +@__entity_equality_address_0_Country_FullName='United States' (Size = 4000) SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_Tags`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName` FROM `Customer` AS `c` -WHERE (((((`c`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `c`.`ShippingAddress_AddressLine2` IS NULL) AND (`c`.`ShippingAddress_Tags` = @__entity_equality_address_0_Tags)) AND (`c`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`c`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Code)) AND (`c`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_FullName) +WHERE (((((`c`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `c`.`ShippingAddress_AddressLine2` IS NULL) AND (`c`.`ShippingAddress_Tags` = @__entity_equality_address_0_Tags)) AND (`c`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`c`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Country_Code)) AND (`c`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_Country_FullName) """); } @@ -264,15 +264,15 @@ public override async Task Contains_over_complex_type(bool async) @__entity_equality_address_0_AddressLine1='804 S. Lakeshore Road' (Size = 4000) @__entity_equality_address_0_Tags='["foo","bar"]' (Size = 4000) @__entity_equality_address_0_ZipCode='38654' (Nullable = true) -@__entity_equality_address_0_Code='US' (Size = 4000) -@__entity_equality_address_0_FullName='United States' (Size = 4000) +@__entity_equality_address_0_Country_Code='US' (Size = 4000) +@__entity_equality_address_0_Country_FullName='United States' (Size = 4000) SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_Tags`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName` FROM `Customer` AS `c` WHERE EXISTS ( SELECT 1 FROM `Customer` AS `c0` - WHERE (((((`c0`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `c0`.`ShippingAddress_AddressLine2` IS NULL) AND (`c0`.`ShippingAddress_Tags` = @__entity_equality_address_0_Tags)) AND (`c0`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`c0`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Code)) AND (`c0`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_FullName)) + WHERE (((((`c0`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `c0`.`ShippingAddress_AddressLine2` IS NULL) AND (`c0`.`ShippingAddress_Tags` = @__entity_equality_address_0_Tags)) AND (`c0`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`c0`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Country_Code)) AND (`c0`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_Country_FullName)) """); } @@ -628,12 +628,12 @@ public override async Task Struct_complex_type_equals_parameter(bool async) """ @__entity_equality_address_0_AddressLine1='804 S. Lakeshore Road' (Size = 4000) @__entity_equality_address_0_ZipCode='38654' (Nullable = true) -@__entity_equality_address_0_Code='US' (Size = 4000) -@__entity_equality_address_0_FullName='United States' (Size = 4000) +@__entity_equality_address_0_Country_Code='US' (Size = 4000) +@__entity_equality_address_0_Country_FullName='United States' (Size = 4000) SELECT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName` FROM `ValuedCustomer` AS `v` -WHERE ((((`v`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `v`.`ShippingAddress_AddressLine2` IS NULL) AND (`v`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`v`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Code)) AND (`v`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_FullName) +WHERE ((((`v`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `v`.`ShippingAddress_AddressLine2` IS NULL) AND (`v`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`v`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Country_Code)) AND (`v`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_Country_FullName) """); } @@ -645,15 +645,15 @@ public override async Task Contains_over_struct_complex_type(bool async) """ @__entity_equality_address_0_AddressLine1='804 S. Lakeshore Road' (Size = 4000) @__entity_equality_address_0_ZipCode='38654' (Nullable = true) -@__entity_equality_address_0_Code='US' (Size = 4000) -@__entity_equality_address_0_FullName='United States' (Size = 4000) +@__entity_equality_address_0_Country_Code='US' (Size = 4000) +@__entity_equality_address_0_Country_FullName='United States' (Size = 4000) SELECT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName` FROM `ValuedCustomer` AS `v` WHERE EXISTS ( SELECT 1 FROM `ValuedCustomer` AS `v0` - WHERE ((((`v0`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `v0`.`ShippingAddress_AddressLine2` IS NULL) AND (`v0`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`v0`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Code)) AND (`v0`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_FullName)) + WHERE ((((`v0`.`ShippingAddress_AddressLine1` = @__entity_equality_address_0_AddressLine1) AND `v0`.`ShippingAddress_AddressLine2` IS NULL) AND (`v0`.`ShippingAddress_ZipCode` = @__entity_equality_address_0_ZipCode)) AND (`v0`.`ShippingAddress_Country_Code` = @__entity_equality_address_0_Country_Code)) AND (`v0`.`ShippingAddress_Country_FullName` = @__entity_equality_address_0_Country_FullName)) """); } @@ -748,9 +748,418 @@ public override async Task Union_property_in_struct_complex_type(bool async) """); } + public override async Task Project_same_nested_complex_type_twice_with_pushdown(bool async) + { + await base.Project_same_nested_complex_type_twice_with_pushdown(async); + + AssertSql( +""" +SELECT `s`.`BillingAddress_AddressLine1`, `s`.`BillingAddress_AddressLine2`, `s`.`BillingAddress_Tags`, `s`.`BillingAddress_ZipCode`, `s`.`BillingAddress_Country_Code`, `s`.`BillingAddress_Country_FullName`, `s`.`BillingAddress_AddressLine10`, `s`.`BillingAddress_AddressLine20`, `s`.`BillingAddress_Tags0`, `s`.`BillingAddress_ZipCode0`, `s`.`BillingAddress_Country_Code0`, `s`.`BillingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0` + FROM `Customer` AS `c` + CROSS JOIN `Customer` AS `c0` +) AS `s` +"""); + } + + public override async Task Project_same_entity_with_nested_complex_type_twice_with_pushdown(bool async) + { + await base.Project_same_entity_with_nested_complex_type_twice_with_pushdown(async); + + AssertSql( +""" +SELECT `s`.`Id`, `s`.`Name`, `s`.`BillingAddress_AddressLine1`, `s`.`BillingAddress_AddressLine2`, `s`.`BillingAddress_Tags`, `s`.`BillingAddress_ZipCode`, `s`.`BillingAddress_Country_Code`, `s`.`BillingAddress_Country_FullName`, `s`.`ShippingAddress_AddressLine1`, `s`.`ShippingAddress_AddressLine2`, `s`.`ShippingAddress_Tags`, `s`.`ShippingAddress_ZipCode`, `s`.`ShippingAddress_Country_Code`, `s`.`ShippingAddress_Country_FullName`, `s`.`Id0`, `s`.`Name0`, `s`.`BillingAddress_AddressLine10`, `s`.`BillingAddress_AddressLine20`, `s`.`BillingAddress_Tags0`, `s`.`BillingAddress_ZipCode0`, `s`.`BillingAddress_Country_Code0`, `s`.`BillingAddress_Country_FullName0`, `s`.`ShippingAddress_AddressLine10`, `s`.`ShippingAddress_AddressLine20`, `s`.`ShippingAddress_Tags0`, `s`.`ShippingAddress_ZipCode0`, `s`.`ShippingAddress_Country_Code0`, `s`.`ShippingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_Tags`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, `c0`.`Id` AS `Id0`, `c0`.`Name` AS `Name0`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c0`.`ShippingAddress_Tags` AS `ShippingAddress_Tags0`, `c0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0` + FROM `Customer` AS `c` + CROSS JOIN `Customer` AS `c0` +) AS `s` +"""); + } + + public override async Task Project_same_nested_complex_type_twice_with_double_pushdown(bool async) + { + await base.Project_same_nested_complex_type_twice_with_double_pushdown(async); + + AssertSql( +""" +@__p_0='50' + +SELECT `s0`.`BillingAddress_AddressLine1`, `s0`.`BillingAddress_AddressLine2`, `s0`.`BillingAddress_Tags`, `s0`.`BillingAddress_ZipCode`, `s0`.`BillingAddress_Country_Code`, `s0`.`BillingAddress_Country_FullName`, `s0`.`BillingAddress_AddressLine10`, `s0`.`BillingAddress_AddressLine20`, `s0`.`BillingAddress_Tags0`, `s0`.`BillingAddress_ZipCode0`, `s0`.`BillingAddress_Country_Code0`, `s0`.`BillingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `s`.`BillingAddress_AddressLine1`, `s`.`BillingAddress_AddressLine2`, `s`.`BillingAddress_Tags`, `s`.`BillingAddress_ZipCode`, `s`.`BillingAddress_Country_Code`, `s`.`BillingAddress_Country_FullName`, `s`.`BillingAddress_AddressLine10`, `s`.`BillingAddress_AddressLine20`, `s`.`BillingAddress_Tags0`, `s`.`BillingAddress_ZipCode0`, `s`.`BillingAddress_Country_Code0`, `s`.`BillingAddress_Country_FullName0` + FROM ( + SELECT `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0` + FROM `Customer` AS `c` + CROSS JOIN `Customer` AS `c0` + ORDER BY `c`.`Id`, `c0`.`Id` + LIMIT @__p_0 + ) AS `s` +) AS `s0` +"""); + } + + public override async Task Project_same_entity_with_nested_complex_type_twice_with_double_pushdown(bool async) + { + await base.Project_same_entity_with_nested_complex_type_twice_with_double_pushdown(async); + + AssertSql( +""" +@__p_0='50' + +SELECT `s0`.`Id`, `s0`.`Name`, `s0`.`BillingAddress_AddressLine1`, `s0`.`BillingAddress_AddressLine2`, `s0`.`BillingAddress_Tags`, `s0`.`BillingAddress_ZipCode`, `s0`.`BillingAddress_Country_Code`, `s0`.`BillingAddress_Country_FullName`, `s0`.`ShippingAddress_AddressLine1`, `s0`.`ShippingAddress_AddressLine2`, `s0`.`ShippingAddress_Tags`, `s0`.`ShippingAddress_ZipCode`, `s0`.`ShippingAddress_Country_Code`, `s0`.`ShippingAddress_Country_FullName`, `s0`.`Id0`, `s0`.`Name0`, `s0`.`BillingAddress_AddressLine10`, `s0`.`BillingAddress_AddressLine20`, `s0`.`BillingAddress_Tags0`, `s0`.`BillingAddress_ZipCode0`, `s0`.`BillingAddress_Country_Code0`, `s0`.`BillingAddress_Country_FullName0`, `s0`.`ShippingAddress_AddressLine10`, `s0`.`ShippingAddress_AddressLine20`, `s0`.`ShippingAddress_Tags0`, `s0`.`ShippingAddress_ZipCode0`, `s0`.`ShippingAddress_Country_Code0`, `s0`.`ShippingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `s`.`Id`, `s`.`Name`, `s`.`BillingAddress_AddressLine1`, `s`.`BillingAddress_AddressLine2`, `s`.`BillingAddress_Tags`, `s`.`BillingAddress_ZipCode`, `s`.`BillingAddress_Country_Code`, `s`.`BillingAddress_Country_FullName`, `s`.`ShippingAddress_AddressLine1`, `s`.`ShippingAddress_AddressLine2`, `s`.`ShippingAddress_Tags`, `s`.`ShippingAddress_ZipCode`, `s`.`ShippingAddress_Country_Code`, `s`.`ShippingAddress_Country_FullName`, `s`.`Id0`, `s`.`Name0`, `s`.`BillingAddress_AddressLine10`, `s`.`BillingAddress_AddressLine20`, `s`.`BillingAddress_Tags0`, `s`.`BillingAddress_ZipCode0`, `s`.`BillingAddress_Country_Code0`, `s`.`BillingAddress_Country_FullName0`, `s`.`ShippingAddress_AddressLine10`, `s`.`ShippingAddress_AddressLine20`, `s`.`ShippingAddress_Tags0`, `s`.`ShippingAddress_ZipCode0`, `s`.`ShippingAddress_Country_Code0`, `s`.`ShippingAddress_Country_FullName0` + FROM ( + SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_Tags`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, `c0`.`Id` AS `Id0`, `c0`.`Name` AS `Name0`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c0`.`ShippingAddress_Tags` AS `ShippingAddress_Tags0`, `c0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0` + FROM `Customer` AS `c` + CROSS JOIN `Customer` AS `c0` + ORDER BY `c`.`Id`, `c0`.`Id` + LIMIT @__p_0 + ) AS `s` +) AS `s0` +"""); + } + + public override async Task Project_same_struct_nested_complex_type_twice_with_pushdown(bool async) + { + await base.Project_same_struct_nested_complex_type_twice_with_pushdown(async); + + AssertSql( +""" +SELECT `s`.`BillingAddress_AddressLine1`, `s`.`BillingAddress_AddressLine2`, `s`.`BillingAddress_ZipCode`, `s`.`BillingAddress_Country_Code`, `s`.`BillingAddress_Country_FullName`, `s`.`BillingAddress_AddressLine10`, `s`.`BillingAddress_AddressLine20`, `s`.`BillingAddress_ZipCode0`, `s`.`BillingAddress_Country_Code0`, `s`.`BillingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `v0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `v0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `v0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `v0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0` + FROM `ValuedCustomer` AS `v` + CROSS JOIN `ValuedCustomer` AS `v0` +) AS `s` +"""); + } + + public override async Task Project_same_entity_with_struct_nested_complex_type_twice_with_pushdown(bool async) + { + await base.Project_same_entity_with_struct_nested_complex_type_twice_with_pushdown(async); + + AssertSql( +""" +SELECT `s`.`Id`, `s`.`Name`, `s`.`BillingAddress_AddressLine1`, `s`.`BillingAddress_AddressLine2`, `s`.`BillingAddress_ZipCode`, `s`.`BillingAddress_Country_Code`, `s`.`BillingAddress_Country_FullName`, `s`.`ShippingAddress_AddressLine1`, `s`.`ShippingAddress_AddressLine2`, `s`.`ShippingAddress_ZipCode`, `s`.`ShippingAddress_Country_Code`, `s`.`ShippingAddress_Country_FullName`, `s`.`Id0`, `s`.`Name0`, `s`.`BillingAddress_AddressLine10`, `s`.`BillingAddress_AddressLine20`, `s`.`BillingAddress_ZipCode0`, `s`.`BillingAddress_Country_Code0`, `s`.`BillingAddress_Country_FullName0`, `s`.`ShippingAddress_AddressLine10`, `s`.`ShippingAddress_AddressLine20`, `s`.`ShippingAddress_ZipCode0`, `s`.`ShippingAddress_Country_Code0`, `s`.`ShippingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName`, `v0`.`Id` AS `Id0`, `v0`.`Name` AS `Name0`, `v0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `v0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `v0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `v0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `v0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `v0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `v0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `v0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `v0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `v0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0` + FROM `ValuedCustomer` AS `v` + CROSS JOIN `ValuedCustomer` AS `v0` +) AS `s` +"""); + } + + public override async Task Project_same_struct_nested_complex_type_twice_with_double_pushdown(bool async) + { + await base.Project_same_struct_nested_complex_type_twice_with_double_pushdown(async); + + AssertSql( +""" +@__p_0='50' + +SELECT `s0`.`BillingAddress_AddressLine1`, `s0`.`BillingAddress_AddressLine2`, `s0`.`BillingAddress_ZipCode`, `s0`.`BillingAddress_Country_Code`, `s0`.`BillingAddress_Country_FullName`, `s0`.`BillingAddress_AddressLine10`, `s0`.`BillingAddress_AddressLine20`, `s0`.`BillingAddress_ZipCode0`, `s0`.`BillingAddress_Country_Code0`, `s0`.`BillingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `s`.`BillingAddress_AddressLine1`, `s`.`BillingAddress_AddressLine2`, `s`.`BillingAddress_ZipCode`, `s`.`BillingAddress_Country_Code`, `s`.`BillingAddress_Country_FullName`, `s`.`BillingAddress_AddressLine10`, `s`.`BillingAddress_AddressLine20`, `s`.`BillingAddress_ZipCode0`, `s`.`BillingAddress_Country_Code0`, `s`.`BillingAddress_Country_FullName0` + FROM ( + SELECT `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `v0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `v0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `v0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `v0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0` + FROM `ValuedCustomer` AS `v` + CROSS JOIN `ValuedCustomer` AS `v0` + ORDER BY `v`.`Id`, `v0`.`Id` + LIMIT @__p_0 + ) AS `s` +) AS `s0` +"""); + } + + public override async Task Project_same_entity_with_struct_nested_complex_type_twice_with_double_pushdown(bool async) + { + await base.Project_same_entity_with_struct_nested_complex_type_twice_with_double_pushdown(async); + + AssertSql( +""" +@__p_0='50' + +SELECT `s0`.`Id`, `s0`.`Name`, `s0`.`BillingAddress_AddressLine1`, `s0`.`BillingAddress_AddressLine2`, `s0`.`BillingAddress_ZipCode`, `s0`.`BillingAddress_Country_Code`, `s0`.`BillingAddress_Country_FullName`, `s0`.`ShippingAddress_AddressLine1`, `s0`.`ShippingAddress_AddressLine2`, `s0`.`ShippingAddress_ZipCode`, `s0`.`ShippingAddress_Country_Code`, `s0`.`ShippingAddress_Country_FullName`, `s0`.`Id0`, `s0`.`Name0`, `s0`.`BillingAddress_AddressLine10`, `s0`.`BillingAddress_AddressLine20`, `s0`.`BillingAddress_ZipCode0`, `s0`.`BillingAddress_Country_Code0`, `s0`.`BillingAddress_Country_FullName0`, `s0`.`ShippingAddress_AddressLine10`, `s0`.`ShippingAddress_AddressLine20`, `s0`.`ShippingAddress_ZipCode0`, `s0`.`ShippingAddress_Country_Code0`, `s0`.`ShippingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `s`.`Id`, `s`.`Name`, `s`.`BillingAddress_AddressLine1`, `s`.`BillingAddress_AddressLine2`, `s`.`BillingAddress_ZipCode`, `s`.`BillingAddress_Country_Code`, `s`.`BillingAddress_Country_FullName`, `s`.`ShippingAddress_AddressLine1`, `s`.`ShippingAddress_AddressLine2`, `s`.`ShippingAddress_ZipCode`, `s`.`ShippingAddress_Country_Code`, `s`.`ShippingAddress_Country_FullName`, `s`.`Id0`, `s`.`Name0`, `s`.`BillingAddress_AddressLine10`, `s`.`BillingAddress_AddressLine20`, `s`.`BillingAddress_ZipCode0`, `s`.`BillingAddress_Country_Code0`, `s`.`BillingAddress_Country_FullName0`, `s`.`ShippingAddress_AddressLine10`, `s`.`ShippingAddress_AddressLine20`, `s`.`ShippingAddress_ZipCode0`, `s`.`ShippingAddress_Country_Code0`, `s`.`ShippingAddress_Country_FullName0` + FROM ( + SELECT `v`.`Id`, `v`.`Name`, `v`.`BillingAddress_AddressLine1`, `v`.`BillingAddress_AddressLine2`, `v`.`BillingAddress_ZipCode`, `v`.`BillingAddress_Country_Code`, `v`.`BillingAddress_Country_FullName`, `v`.`ShippingAddress_AddressLine1`, `v`.`ShippingAddress_AddressLine2`, `v`.`ShippingAddress_ZipCode`, `v`.`ShippingAddress_Country_Code`, `v`.`ShippingAddress_Country_FullName`, `v0`.`Id` AS `Id0`, `v0`.`Name` AS `Name0`, `v0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `v0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `v0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `v0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `v0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `v0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `v0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `v0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `v0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `v0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0` + FROM `ValuedCustomer` AS `v` + CROSS JOIN `ValuedCustomer` AS `v0` + ORDER BY `v`.`Id`, `v0`.`Id` + LIMIT @__p_0 + ) AS `s` +) AS `s0` +"""); + } + + public override async Task Union_of_same_entity_with_nested_complex_type_projected_twice_with_pushdown(bool async) + { + await base.Union_of_same_entity_with_nested_complex_type_projected_twice_with_pushdown(async); + + AssertSql( +""" +@__p_0='50' + +SELECT `u`.`Id`, `u`.`Name`, `u`.`BillingAddress_AddressLine1`, `u`.`BillingAddress_AddressLine2`, `u`.`BillingAddress_Tags`, `u`.`BillingAddress_ZipCode`, `u`.`BillingAddress_Country_Code`, `u`.`BillingAddress_Country_FullName`, `u`.`ShippingAddress_AddressLine1`, `u`.`ShippingAddress_AddressLine2`, `u`.`ShippingAddress_Tags`, `u`.`ShippingAddress_ZipCode`, `u`.`ShippingAddress_Country_Code`, `u`.`ShippingAddress_Country_FullName`, `u`.`Id0`, `u`.`Name0`, `u`.`BillingAddress_AddressLine10`, `u`.`BillingAddress_AddressLine20`, `u`.`BillingAddress_Tags0`, `u`.`BillingAddress_ZipCode0`, `u`.`BillingAddress_Country_Code0`, `u`.`BillingAddress_Country_FullName0`, `u`.`ShippingAddress_AddressLine10`, `u`.`ShippingAddress_AddressLine20`, `u`.`ShippingAddress_Tags0`, `u`.`ShippingAddress_ZipCode0`, `u`.`ShippingAddress_Country_Code0`, `u`.`ShippingAddress_Country_FullName0` +FROM ( + SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_Tags`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, `c0`.`Id` AS `Id0`, `c0`.`Name` AS `Name0`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c0`.`ShippingAddress_Tags` AS `ShippingAddress_Tags0`, `c0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0` + FROM `Customer` AS `c` + CROSS JOIN `Customer` AS `c0` + UNION + SELECT `c1`.`Id`, `c1`.`Name`, `c1`.`BillingAddress_AddressLine1`, `c1`.`BillingAddress_AddressLine2`, `c1`.`BillingAddress_Tags`, `c1`.`BillingAddress_ZipCode`, `c1`.`BillingAddress_Country_Code`, `c1`.`BillingAddress_Country_FullName`, `c1`.`ShippingAddress_AddressLine1`, `c1`.`ShippingAddress_AddressLine2`, `c1`.`ShippingAddress_Tags`, `c1`.`ShippingAddress_ZipCode`, `c1`.`ShippingAddress_Country_Code`, `c1`.`ShippingAddress_Country_FullName`, `c2`.`Id` AS `Id0`, `c2`.`Name` AS `Name0`, `c2`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c2`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c2`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c2`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c2`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c2`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c2`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c2`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c2`.`ShippingAddress_Tags` AS `ShippingAddress_Tags0`, `c2`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c2`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c2`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0` + FROM `Customer` AS `c1` + CROSS JOIN `Customer` AS `c2` +) AS `u` +ORDER BY `u`.`Id`, `u`.`Id0` +LIMIT @__p_0 +"""); + } + + public override async Task Union_of_same_entity_with_nested_complex_type_projected_twice_with_double_pushdown(bool async) + { + await base.Union_of_same_entity_with_nested_complex_type_projected_twice_with_double_pushdown(async); + + AssertSql( +""" +@__p_0='50' + +SELECT `u1`.`Id`, `u1`.`Name`, `u1`.`BillingAddress_AddressLine1`, `u1`.`BillingAddress_AddressLine2`, `u1`.`BillingAddress_Tags`, `u1`.`BillingAddress_ZipCode`, `u1`.`BillingAddress_Country_Code`, `u1`.`BillingAddress_Country_FullName`, `u1`.`ShippingAddress_AddressLine1`, `u1`.`ShippingAddress_AddressLine2`, `u1`.`ShippingAddress_Tags`, `u1`.`ShippingAddress_ZipCode`, `u1`.`ShippingAddress_Country_Code`, `u1`.`ShippingAddress_Country_FullName`, `u1`.`Id0`, `u1`.`Name0`, `u1`.`BillingAddress_AddressLine10`, `u1`.`BillingAddress_AddressLine20`, `u1`.`BillingAddress_Tags0`, `u1`.`BillingAddress_ZipCode0`, `u1`.`BillingAddress_Country_Code0`, `u1`.`BillingAddress_Country_FullName0`, `u1`.`ShippingAddress_AddressLine10`, `u1`.`ShippingAddress_AddressLine20`, `u1`.`ShippingAddress_Tags0`, `u1`.`ShippingAddress_ZipCode0`, `u1`.`ShippingAddress_Country_Code0`, `u1`.`ShippingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `u0`.`Id`, `u0`.`Name`, `u0`.`BillingAddress_AddressLine1`, `u0`.`BillingAddress_AddressLine2`, `u0`.`BillingAddress_Tags`, `u0`.`BillingAddress_ZipCode`, `u0`.`BillingAddress_Country_Code`, `u0`.`BillingAddress_Country_FullName`, `u0`.`ShippingAddress_AddressLine1`, `u0`.`ShippingAddress_AddressLine2`, `u0`.`ShippingAddress_Tags`, `u0`.`ShippingAddress_ZipCode`, `u0`.`ShippingAddress_Country_Code`, `u0`.`ShippingAddress_Country_FullName`, `u0`.`Id0`, `u0`.`Name0`, `u0`.`BillingAddress_AddressLine10`, `u0`.`BillingAddress_AddressLine20`, `u0`.`BillingAddress_Tags0`, `u0`.`BillingAddress_ZipCode0`, `u0`.`BillingAddress_Country_Code0`, `u0`.`BillingAddress_Country_FullName0`, `u0`.`ShippingAddress_AddressLine10`, `u0`.`ShippingAddress_AddressLine20`, `u0`.`ShippingAddress_Tags0`, `u0`.`ShippingAddress_ZipCode0`, `u0`.`ShippingAddress_Country_Code0`, `u0`.`ShippingAddress_Country_FullName0` + FROM ( + SELECT `u`.`Id`, `u`.`Name`, `u`.`BillingAddress_AddressLine1`, `u`.`BillingAddress_AddressLine2`, `u`.`BillingAddress_Tags`, `u`.`BillingAddress_ZipCode`, `u`.`BillingAddress_Country_Code`, `u`.`BillingAddress_Country_FullName`, `u`.`ShippingAddress_AddressLine1`, `u`.`ShippingAddress_AddressLine2`, `u`.`ShippingAddress_Tags`, `u`.`ShippingAddress_ZipCode`, `u`.`ShippingAddress_Country_Code`, `u`.`ShippingAddress_Country_FullName`, `u`.`Id0`, `u`.`Name0`, `u`.`BillingAddress_AddressLine10`, `u`.`BillingAddress_AddressLine20`, `u`.`BillingAddress_Tags0`, `u`.`BillingAddress_ZipCode0`, `u`.`BillingAddress_Country_Code0`, `u`.`BillingAddress_Country_FullName0`, `u`.`ShippingAddress_AddressLine10`, `u`.`ShippingAddress_AddressLine20`, `u`.`ShippingAddress_Tags0`, `u`.`ShippingAddress_ZipCode0`, `u`.`ShippingAddress_Country_Code0`, `u`.`ShippingAddress_Country_FullName0` + FROM ( + SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_Tags`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, `c0`.`Id` AS `Id0`, `c0`.`Name` AS `Name0`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c0`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c0`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c0`.`ShippingAddress_Tags` AS `ShippingAddress_Tags0`, `c0`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c0`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c0`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0` + FROM `Customer` AS `c` + CROSS JOIN `Customer` AS `c0` + UNION + SELECT `c1`.`Id`, `c1`.`Name`, `c1`.`BillingAddress_AddressLine1`, `c1`.`BillingAddress_AddressLine2`, `c1`.`BillingAddress_Tags`, `c1`.`BillingAddress_ZipCode`, `c1`.`BillingAddress_Country_Code`, `c1`.`BillingAddress_Country_FullName`, `c1`.`ShippingAddress_AddressLine1`, `c1`.`ShippingAddress_AddressLine2`, `c1`.`ShippingAddress_Tags`, `c1`.`ShippingAddress_ZipCode`, `c1`.`ShippingAddress_Country_Code`, `c1`.`ShippingAddress_Country_FullName`, `c2`.`Id` AS `Id0`, `c2`.`Name` AS `Name0`, `c2`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c2`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c2`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c2`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c2`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c2`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c2`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c2`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c2`.`ShippingAddress_Tags` AS `ShippingAddress_Tags0`, `c2`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c2`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c2`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0` + FROM `Customer` AS `c1` + CROSS JOIN `Customer` AS `c2` + ) AS `u` + ORDER BY `u`.`Id`, `u`.`Id0` + LIMIT @__p_0 + ) AS `u0` +) AS `u1` +ORDER BY `u1`.`Id`, `u1`.`Id0` +LIMIT @__p_0 +"""); + } + + public override async Task Union_of_same_nested_complex_type_projected_twice_with_pushdown(bool async) + { + await base.Union_of_same_nested_complex_type_projected_twice_with_pushdown(async); + + AssertSql( +""" +@__p_0='50' + +SELECT `u`.`BillingAddress_AddressLine1`, `u`.`BillingAddress_AddressLine2`, `u`.`BillingAddress_Tags`, `u`.`BillingAddress_ZipCode`, `u`.`BillingAddress_Country_Code`, `u`.`BillingAddress_Country_FullName`, `u`.`BillingAddress_AddressLine10`, `u`.`BillingAddress_AddressLine20`, `u`.`BillingAddress_Tags0`, `u`.`BillingAddress_ZipCode0`, `u`.`BillingAddress_Country_Code0`, `u`.`BillingAddress_Country_FullName0` +FROM ( + SELECT `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0` + FROM `Customer` AS `c` + CROSS JOIN `Customer` AS `c0` + UNION + SELECT `c1`.`BillingAddress_AddressLine1`, `c1`.`BillingAddress_AddressLine2`, `c1`.`BillingAddress_Tags`, `c1`.`BillingAddress_ZipCode`, `c1`.`BillingAddress_Country_Code`, `c1`.`BillingAddress_Country_FullName`, `c2`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c2`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c2`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c2`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c2`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c2`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0` + FROM `Customer` AS `c1` + CROSS JOIN `Customer` AS `c2` +) AS `u` +ORDER BY `u`.`BillingAddress_ZipCode`, `u`.`BillingAddress_ZipCode0` +LIMIT @__p_0 +"""); + } + + public override async Task Union_of_same_nested_complex_type_projected_twice_with_double_pushdown(bool async) + { + await base.Union_of_same_nested_complex_type_projected_twice_with_double_pushdown(async); + + AssertSql( +""" +@__p_0='50' + +SELECT `u1`.`BillingAddress_AddressLine1`, `u1`.`BillingAddress_AddressLine2`, `u1`.`BillingAddress_Tags`, `u1`.`BillingAddress_ZipCode`, `u1`.`BillingAddress_Country_Code`, `u1`.`BillingAddress_Country_FullName`, `u1`.`BillingAddress_AddressLine10`, `u1`.`BillingAddress_AddressLine20`, `u1`.`BillingAddress_Tags0`, `u1`.`BillingAddress_ZipCode0`, `u1`.`BillingAddress_Country_Code0`, `u1`.`BillingAddress_Country_FullName0` +FROM ( + SELECT DISTINCT `u0`.`BillingAddress_AddressLine1`, `u0`.`BillingAddress_AddressLine2`, `u0`.`BillingAddress_Tags`, `u0`.`BillingAddress_ZipCode`, `u0`.`BillingAddress_Country_Code`, `u0`.`BillingAddress_Country_FullName`, `u0`.`BillingAddress_AddressLine10`, `u0`.`BillingAddress_AddressLine20`, `u0`.`BillingAddress_Tags0`, `u0`.`BillingAddress_ZipCode0`, `u0`.`BillingAddress_Country_Code0`, `u0`.`BillingAddress_Country_FullName0` + FROM ( + SELECT `u`.`BillingAddress_AddressLine1`, `u`.`BillingAddress_AddressLine2`, `u`.`BillingAddress_Tags`, `u`.`BillingAddress_ZipCode`, `u`.`BillingAddress_Country_Code`, `u`.`BillingAddress_Country_FullName`, `u`.`BillingAddress_AddressLine10`, `u`.`BillingAddress_AddressLine20`, `u`.`BillingAddress_Tags0`, `u`.`BillingAddress_ZipCode0`, `u`.`BillingAddress_Country_Code0`, `u`.`BillingAddress_Country_FullName0` + FROM ( + SELECT `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c0`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c0`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c0`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c0`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c0`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c0`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0` + FROM `Customer` AS `c` + CROSS JOIN `Customer` AS `c0` + UNION + SELECT `c1`.`BillingAddress_AddressLine1`, `c1`.`BillingAddress_AddressLine2`, `c1`.`BillingAddress_Tags`, `c1`.`BillingAddress_ZipCode`, `c1`.`BillingAddress_Country_Code`, `c1`.`BillingAddress_Country_FullName`, `c2`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c2`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c2`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c2`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c2`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c2`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0` + FROM `Customer` AS `c1` + CROSS JOIN `Customer` AS `c2` + ) AS `u` + ORDER BY `u`.`BillingAddress_ZipCode`, `u`.`BillingAddress_ZipCode0` + LIMIT @__p_0 + ) AS `u0` +) AS `u1` +ORDER BY `u1`.`BillingAddress_ZipCode`, `u1`.`BillingAddress_ZipCode0` +LIMIT @__p_0 +"""); + } + + public override async Task Same_entity_with_complex_type_projected_twice_with_pushdown_as_part_of_another_projection(bool async) + { + await base.Same_entity_with_complex_type_projected_twice_with_pushdown_as_part_of_another_projection(async); + + AssertSql( +""" +SELECT `c`.`Id`, `s`.`Id`, `s`.`Name`, `s`.`BillingAddress_AddressLine1`, `s`.`BillingAddress_AddressLine2`, `s`.`BillingAddress_Tags`, `s`.`BillingAddress_ZipCode`, `s`.`BillingAddress_Country_Code`, `s`.`BillingAddress_Country_FullName`, `s`.`ShippingAddress_AddressLine1`, `s`.`ShippingAddress_AddressLine2`, `s`.`ShippingAddress_Tags`, `s`.`ShippingAddress_ZipCode`, `s`.`ShippingAddress_Country_Code`, `s`.`ShippingAddress_Country_FullName`, `s`.`Id0`, `s`.`Name0`, `s`.`BillingAddress_AddressLine10`, `s`.`BillingAddress_AddressLine20`, `s`.`BillingAddress_Tags0`, `s`.`BillingAddress_ZipCode0`, `s`.`BillingAddress_Country_Code0`, `s`.`BillingAddress_Country_FullName0`, `s`.`ShippingAddress_AddressLine10`, `s`.`ShippingAddress_AddressLine20`, `s`.`ShippingAddress_Tags0`, `s`.`ShippingAddress_ZipCode0`, `s`.`ShippingAddress_Country_Code0`, `s`.`ShippingAddress_Country_FullName0`, `s`.`c` +FROM `Customer` AS `c` +LEFT JOIN LATERAL ( + SELECT `c0`.`Id`, `c0`.`Name`, `c0`.`BillingAddress_AddressLine1`, `c0`.`BillingAddress_AddressLine2`, `c0`.`BillingAddress_Tags`, `c0`.`BillingAddress_ZipCode`, `c0`.`BillingAddress_Country_Code`, `c0`.`BillingAddress_Country_FullName`, `c0`.`ShippingAddress_AddressLine1`, `c0`.`ShippingAddress_AddressLine2`, `c0`.`ShippingAddress_Tags`, `c0`.`ShippingAddress_ZipCode`, `c0`.`ShippingAddress_Country_Code`, `c0`.`ShippingAddress_Country_FullName`, `c1`.`Id` AS `Id0`, `c1`.`Name` AS `Name0`, `c1`.`BillingAddress_AddressLine1` AS `BillingAddress_AddressLine10`, `c1`.`BillingAddress_AddressLine2` AS `BillingAddress_AddressLine20`, `c1`.`BillingAddress_Tags` AS `BillingAddress_Tags0`, `c1`.`BillingAddress_ZipCode` AS `BillingAddress_ZipCode0`, `c1`.`BillingAddress_Country_Code` AS `BillingAddress_Country_Code0`, `c1`.`BillingAddress_Country_FullName` AS `BillingAddress_Country_FullName0`, `c1`.`ShippingAddress_AddressLine1` AS `ShippingAddress_AddressLine10`, `c1`.`ShippingAddress_AddressLine2` AS `ShippingAddress_AddressLine20`, `c1`.`ShippingAddress_Tags` AS `ShippingAddress_Tags0`, `c1`.`ShippingAddress_ZipCode` AS `ShippingAddress_ZipCode0`, `c1`.`ShippingAddress_Country_Code` AS `ShippingAddress_Country_Code0`, `c1`.`ShippingAddress_Country_FullName` AS `ShippingAddress_Country_FullName0`, 1 AS `c` + FROM `Customer` AS `c0` + CROSS JOIN `Customer` AS `c1` + ORDER BY `c0`.`Id`, `c1`.`Id` DESC + LIMIT 1 +) AS `s` ON TRUE +"""); + } + + public override async Task Same_complex_type_projected_twice_with_pushdown_as_part_of_another_projection(bool async) + { + await base.Same_complex_type_projected_twice_with_pushdown_as_part_of_another_projection(async); + + AssertSql(); + } + + public override async Task GroupBy_over_property_in_nested_complex_type(bool async) + { + await base.GroupBy_over_property_in_nested_complex_type(async); + + AssertSql( +""" +SELECT `c`.`ShippingAddress_Country_Code` AS `Code`, COUNT(*) AS `Count` +FROM `Customer` AS `c` +GROUP BY `c`.`ShippingAddress_Country_Code` +"""); + } + + public override async Task GroupBy_over_complex_type(bool async) + { + await base.GroupBy_over_complex_type(async); + + AssertSql( +""" +SELECT `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_Tags`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, COUNT(*) AS `Count` +FROM `Customer` AS `c` +GROUP BY `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_Tags`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName` +"""); + } + + public override async Task GroupBy_over_nested_complex_type(bool async) + { + await base.GroupBy_over_nested_complex_type(async); + + AssertSql( +""" +SELECT `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName`, COUNT(*) AS `Count` +FROM `Customer` AS `c` +GROUP BY `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName` +"""); + } + + public override async Task Entity_with_complex_type_with_group_by_and_first(bool async) + { + await base.Entity_with_complex_type_with_group_by_and_first(async); + + AssertSql( +""" +SELECT `c3`.`Id`, `c3`.`Name`, `c3`.`BillingAddress_AddressLine1`, `c3`.`BillingAddress_AddressLine2`, `c3`.`BillingAddress_Tags`, `c3`.`BillingAddress_ZipCode`, `c3`.`BillingAddress_Country_Code`, `c3`.`BillingAddress_Country_FullName`, `c3`.`ShippingAddress_AddressLine1`, `c3`.`ShippingAddress_AddressLine2`, `c3`.`ShippingAddress_Tags`, `c3`.`ShippingAddress_ZipCode`, `c3`.`ShippingAddress_Country_Code`, `c3`.`ShippingAddress_Country_FullName` +FROM ( + SELECT `c`.`Id` + FROM `Customer` AS `c` + GROUP BY `c`.`Id` +) AS `c1` +LEFT JOIN ( + SELECT `c2`.`Id`, `c2`.`Name`, `c2`.`BillingAddress_AddressLine1`, `c2`.`BillingAddress_AddressLine2`, `c2`.`BillingAddress_Tags`, `c2`.`BillingAddress_ZipCode`, `c2`.`BillingAddress_Country_Code`, `c2`.`BillingAddress_Country_FullName`, `c2`.`ShippingAddress_AddressLine1`, `c2`.`ShippingAddress_AddressLine2`, `c2`.`ShippingAddress_Tags`, `c2`.`ShippingAddress_ZipCode`, `c2`.`ShippingAddress_Country_Code`, `c2`.`ShippingAddress_Country_FullName` + FROM ( + SELECT `c0`.`Id`, `c0`.`Name`, `c0`.`BillingAddress_AddressLine1`, `c0`.`BillingAddress_AddressLine2`, `c0`.`BillingAddress_Tags`, `c0`.`BillingAddress_ZipCode`, `c0`.`BillingAddress_Country_Code`, `c0`.`BillingAddress_Country_FullName`, `c0`.`ShippingAddress_AddressLine1`, `c0`.`ShippingAddress_AddressLine2`, `c0`.`ShippingAddress_Tags`, `c0`.`ShippingAddress_ZipCode`, `c0`.`ShippingAddress_Country_Code`, `c0`.`ShippingAddress_Country_FullName`, ROW_NUMBER() OVER(PARTITION BY `c0`.`Id` ORDER BY `c0`.`Id`) AS `row` + FROM `Customer` AS `c0` + ) AS `c2` + WHERE `c2`.`row` <= 1 +) AS `c3` ON `c1`.`Id` = `c3`.`Id` +"""); + } + + public override async Task Projecting_property_of_complex_type_using_left_join_with_pushdown(bool async) + { + await base.Projecting_property_of_complex_type_using_left_join_with_pushdown(async); + + AssertSql( +""" +SELECT `c1`.`BillingAddress_ZipCode` +FROM `CustomerGroup` AS `c` +LEFT JOIN ( + SELECT `c0`.`Id`, `c0`.`BillingAddress_ZipCode` + FROM `Customer` AS `c0` + WHERE `c0`.`Id` > 5 +) AS `c1` ON `c`.`Id` = `c1`.`Id` +"""); + } + + public override async Task Projecting_complex_from_optional_navigation_using_conditional(bool async) + { + await base.Projecting_complex_from_optional_navigation_using_conditional(async); + + AssertSql( +""" +@__p_0='20' + +SELECT `s0`.`ShippingAddress_ZipCode` +FROM ( + SELECT DISTINCT `s`.`ShippingAddress_AddressLine1`, `s`.`ShippingAddress_AddressLine2`, `s`.`ShippingAddress_Tags`, `s`.`ShippingAddress_ZipCode`, `s`.`ShippingAddress_Country_Code`, `s`.`ShippingAddress_Country_FullName` + FROM ( + SELECT `c0`.`ShippingAddress_AddressLine1`, `c0`.`ShippingAddress_AddressLine2`, `c0`.`ShippingAddress_Tags`, `c0`.`ShippingAddress_ZipCode`, `c0`.`ShippingAddress_Country_Code`, `c0`.`ShippingAddress_Country_FullName` + FROM `CustomerGroup` AS `c` + LEFT JOIN `Customer` AS `c0` ON `c`.`OptionalCustomerId` = `c0`.`Id` + ORDER BY `c0`.`ShippingAddress_ZipCode` + LIMIT @__p_0 + ) AS `s` +) AS `s0` +"""); + } + + public override async Task Project_entity_with_complex_type_pushdown_and_then_left_join(bool async) + { + await base.Project_entity_with_complex_type_pushdown_and_then_left_join(async); + + AssertSql( +""" +@__p_0='20' +@__p_1='30' + +SELECT `c3`.`BillingAddress_ZipCode` AS `Zip1`, `c4`.`ShippingAddress_ZipCode` AS `Zip2` +FROM ( + SELECT DISTINCT `c0`.`Id`, `c0`.`Name`, `c0`.`BillingAddress_AddressLine1`, `c0`.`BillingAddress_AddressLine2`, `c0`.`BillingAddress_Tags`, `c0`.`BillingAddress_ZipCode`, `c0`.`BillingAddress_Country_Code`, `c0`.`BillingAddress_Country_FullName`, `c0`.`ShippingAddress_AddressLine1`, `c0`.`ShippingAddress_AddressLine2`, `c0`.`ShippingAddress_Tags`, `c0`.`ShippingAddress_ZipCode`, `c0`.`ShippingAddress_Country_Code`, `c0`.`ShippingAddress_Country_FullName` + FROM ( + SELECT `c`.`Id`, `c`.`Name`, `c`.`BillingAddress_AddressLine1`, `c`.`BillingAddress_AddressLine2`, `c`.`BillingAddress_Tags`, `c`.`BillingAddress_ZipCode`, `c`.`BillingAddress_Country_Code`, `c`.`BillingAddress_Country_FullName`, `c`.`ShippingAddress_AddressLine1`, `c`.`ShippingAddress_AddressLine2`, `c`.`ShippingAddress_Tags`, `c`.`ShippingAddress_ZipCode`, `c`.`ShippingAddress_Country_Code`, `c`.`ShippingAddress_Country_FullName` + FROM `Customer` AS `c` + ORDER BY `c`.`Id` + LIMIT @__p_0 + ) AS `c0` +) AS `c3` +LEFT JOIN ( + SELECT DISTINCT `c2`.`Id`, `c2`.`Name`, `c2`.`BillingAddress_AddressLine1`, `c2`.`BillingAddress_AddressLine2`, `c2`.`BillingAddress_Tags`, `c2`.`BillingAddress_ZipCode`, `c2`.`BillingAddress_Country_Code`, `c2`.`BillingAddress_Country_FullName`, `c2`.`ShippingAddress_AddressLine1`, `c2`.`ShippingAddress_AddressLine2`, `c2`.`ShippingAddress_Tags`, `c2`.`ShippingAddress_ZipCode`, `c2`.`ShippingAddress_Country_Code`, `c2`.`ShippingAddress_Country_FullName` + FROM ( + SELECT `c1`.`Id`, `c1`.`Name`, `c1`.`BillingAddress_AddressLine1`, `c1`.`BillingAddress_AddressLine2`, `c1`.`BillingAddress_Tags`, `c1`.`BillingAddress_ZipCode`, `c1`.`BillingAddress_Country_Code`, `c1`.`BillingAddress_Country_FullName`, `c1`.`ShippingAddress_AddressLine1`, `c1`.`ShippingAddress_AddressLine2`, `c1`.`ShippingAddress_Tags`, `c1`.`ShippingAddress_ZipCode`, `c1`.`ShippingAddress_Country_Code`, `c1`.`ShippingAddress_Country_FullName` + FROM `Customer` AS `c1` + ORDER BY `c1`.`Id` DESC + LIMIT @__p_1 + ) AS `c2` +) AS `c4` ON `c3`.`Id` = `c4`.`Id` +"""); + } + [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); diff --git a/test/EFCore.MySql.FunctionalTests/Query/CompositeKeysQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/CompositeKeysQueryMySqlTest.cs index 5bfbf4660..0a99234cc 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/CompositeKeysQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/CompositeKeysQueryMySqlTest.cs @@ -15,9 +15,6 @@ public CompositeKeysQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - public override async Task Projecting_multiple_collections_same_level_top_level_ordering(bool async) { await base.Projecting_multiple_collections_same_level_top_level_ordering(async); diff --git a/test/EFCore.MySql.FunctionalTests/Query/CompositeKeysSplitQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/CompositeKeysSplitQueryMySqlTest.cs index 504d921ed..ad90f7426 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/CompositeKeysSplitQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/CompositeKeysSplitQueryMySqlTest.cs @@ -15,9 +15,6 @@ public CompositeKeysSplitQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - public override async Task Projecting_collections_multi_level(bool async) { await base.Projecting_collections_multi_level(async); diff --git a/test/EFCore.MySql.FunctionalTests/Query/DateOnlyQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/DateOnlyQueryMySqlTest.cs index a0f957dd2..43937b2e5 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/DateOnlyQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/DateOnlyQueryMySqlTest.cs @@ -183,7 +183,7 @@ protected DateOnlyQueryMySqlTestBase(TFixture fixture) protected virtual DbContext CreateContext() => Fixture.CreateContext(); - public abstract class DateOnlyQueryMySqlFixtureBase : SharedStoreFixtureBase, IQueryFixtureBase + public abstract class DateOnlyQueryMySqlFixtureBase : SharedStoreFixtureBase, IQueryFixtureBase, ITestSqlLoggerFactory { protected override string StoreName => "DateOnlyQueryTest"; public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; diff --git a/test/EFCore.MySql.FunctionalTests/Query/Ef6GroupByMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/Ef6GroupByMySqlTest.cs index cbb747070..e18c57229 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/Ef6GroupByMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/Ef6GroupByMySqlTest.cs @@ -20,7 +20,7 @@ public Ef6GroupByMySqlTest(Ef6GroupByMySqlFixture fixture, ITestOutputHelper tes [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task GroupBy_is_optimized_when_projecting_group_key(bool async) { @@ -165,12 +165,10 @@ public override async Task GroupBy_is_optimized_when_projecting_conditional_expr AssertSql( """ -@__p_0='False' - SELECT CASE WHEN `a`.`FirstName` IS NULL THEN 'is null' ELSE 'not null' -END AS `keyIsNull`, @__p_0 AS `logicExpression` +END AS `keyIsNull`, FALSE AS `logicExpression` FROM `ArubaOwner` AS `a` GROUP BY `a`.`FirstName` """); @@ -186,10 +184,10 @@ GROUP BY `a`.`FirstName` // ) AS [Distinct1]"; } - public override async Task GroupBy_is_optimized_when_filerting_and_projecting_anonymous_type_with_group_key_and_function_aggregate( + public override async Task GroupBy_is_optimized_when_filtering_and_projecting_anonymous_type_with_group_key_and_function_aggregate( bool async) { - await base.GroupBy_is_optimized_when_filerting_and_projecting_anonymous_type_with_group_key_and_function_aggregate(async); + await base.GroupBy_is_optimized_when_filtering_and_projecting_anonymous_type_with_group_key_and_function_aggregate(async); AssertSql( $""" @@ -489,12 +487,11 @@ public override async Task Group_Join_from_LINQ_101(bool async) """ SELECT `c`.`Id`, `c`.`CompanyName`, `c`.`Region`, `s`.`Id`, `s`.`CustomerId`, `s`.`OrderDate`, `s`.`Total`, `s`.`Id0` FROM `CustomerForLinq` AS `c` -LEFT JOIN LATERAL ( +LEFT JOIN ( SELECT `o`.`Id`, `o`.`CustomerId`, `o`.`OrderDate`, `o`.`Total`, `c0`.`Id` AS `Id0` FROM `OrderForLinq` AS `o` LEFT JOIN `CustomerForLinq` AS `c0` ON `o`.`CustomerId` = `c0`.`Id` - WHERE `c`.`Id` = `c0`.`Id` -) AS `s` ON TRUE +) AS `s` ON `c`.`Id` = `s`.`Id0` ORDER BY `c`.`Id`, `s`.`Id` """); } @@ -912,7 +909,7 @@ LEFT JOIN ( private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); - public class Ef6GroupByMySqlFixture : Ef6GroupByFixtureBase + public class Ef6GroupByMySqlFixture : Ef6GroupByFixtureBase, ITestSqlLoggerFactory { public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; diff --git a/test/EFCore.MySql.FunctionalTests/Query/EntitySplittingQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/EntitySplittingQueryMySqlTest.cs index 4240725e0..d1456a8ab 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/EntitySplittingQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/EntitySplittingQueryMySqlTest.cs @@ -16,7 +16,7 @@ public EntitySplittingQueryMySqlTest(ITestOutputHelper testOutputHelper) [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Can_query_entity_which_is_split_in_two(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlNoBackslashesTest.cs b/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlNoBackslashesTest.cs index 691a5af80..461cdc759 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlNoBackslashesTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlNoBackslashesTest.cs @@ -17,9 +17,9 @@ public EscapesMySqlNoBackslashesTest(EscapesMySqlNoBackslashesFixture fixture, I } [ConditionalFact] - public override void Input_query_escapes_parameter() + public override async Task Input_query_escapes_parameter() { - base.Input_query_escapes_parameter(); + await base.Input_query_escapes_parameter(); if (AppConfig.ServerVersion.Supports.Returning) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlTest.cs index ab121f014..d58d53b60 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlTest.cs @@ -16,9 +16,9 @@ public EscapesMySqlTest(EscapesMySqlFixture fixture, ITestOutputHelper testOutpu } [ConditionalFact] - public override void Input_query_escapes_parameter() + public override async Task Input_query_escapes_parameter() { - base.Input_query_escapes_parameter(); + await base.Input_query_escapes_parameter(); if (AppConfig.ServerVersion.Supports.Returning) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlTestBase.cs b/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlTestBase.cs index 53a2ce84b..ac08eae8d 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlTestBase.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/EscapesMySqlTestBase.cs @@ -24,21 +24,21 @@ protected EscapesMySqlTestBase(TFixture fixture) } [ConditionalFact] - public virtual void Input_query_escapes_parameter() + public virtual async Task Input_query_escapes_parameter() { - ExecuteWithStrategyInTransaction( - context => + await ExecuteWithStrategyInTransactionAsync( + async context => { context.Artists.Add(new Artist { Name = @"Back\slash's Garden Party", }); - context.SaveChanges(); + await context.SaveChangesAsync(); }, - context => + async context => { - var artists = context.Artists.Where(x => x.Name.EndsWith(" Garden Party")).ToList(); + var artists = await context.Artists.Where(x => x.Name.EndsWith(" Garden Party")).ToListAsync(); Assert.Single(artists); Assert.True(artists[0].Name == @"Back\slash's Garden Party"); }); @@ -108,18 +108,16 @@ public virtual async Task Where_contains_query_escapes(bool async) protected void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); - protected virtual void ExecuteWithStrategyInTransaction( - Action testOperation, - Action nestedTestOperation1 = null, - Action nestedTestOperation2 = null) - { - TestHelpers.ExecuteWithStrategyInTransaction( + protected virtual Task ExecuteWithStrategyInTransactionAsync( + Func testOperation, + Func nestedTestOperation1 = null, + Func nestedTestOperation2 = null) + => TestHelpers.ExecuteWithStrategyInTransactionAsync( CreateContext, UseTransaction, testOperation, nestedTestOperation1, nestedTestOperation2); - } protected virtual void UseTransaction(DatabaseFacade facade, IDbContextTransaction transaction) => facade.UseTransaction(transaction.GetDbTransaction()); @@ -137,7 +135,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder, DbContext con MySqlTestHelpers.Instance.EnsureSufficientKeySpace(modelBuilder.Model, TestStore); } - protected override void Seed(MusicStoreContext context) + protected override async Task SeedAsync(MusicStoreContext context) { context.Artists.AddRange( new Artist { ArtistId = 1, Name = @"Back\slasher's" }, @@ -145,7 +143,7 @@ protected override void Seed(MusicStoreContext context) new Artist { ArtistId = 3, Name = @"John's Chill Box" } ); - context.SaveChanges(); + await context.SaveChangesAsync(); } } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/FunkyDataQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/FunkyDataQueryMySqlTest.cs index bc3fd0740..0cfb7c607 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/FunkyDataQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/FunkyDataQueryMySqlTest.cs @@ -195,7 +195,7 @@ protected override void ClearLog() private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); - public class FunkyDataQueryMySqlFixture : FunkyDataQueryFixtureBase + public class FunkyDataQueryMySqlFixture : FunkyDataQueryFixtureBase, ITestSqlLoggerFactory { public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ServiceProvider.GetRequiredService(); diff --git a/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.MySql.cs b/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.MySql.cs index 7a537a2cc..1aae4b327 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.MySql.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.MySql.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Data.Common; using System.Linq; @@ -206,9 +206,9 @@ await AssertQuery( ss => ss.Set().Where(e => e.Timeline == e.Timeline.DateTime), ss => ss.Set().Where(e => true)); - AssertSql( - """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` + AssertSql( +""" +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE `m`.`Timeline` = `m`.`Timeline` """); @@ -223,9 +223,9 @@ await AssertQuery( ss => ss.Set().Where(e => e.Timeline == e.Timeline.UtcDateTime), ss => ss.Set().Where(e => true)); - AssertSql( - """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` + AssertSql( +""" +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE `m`.`Timeline` = `m`.`Timeline` """); diff --git a/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.cs index 61da8c51d..081add88c 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/GearsOfWarQueryMySqlTest.cs @@ -21,9 +21,6 @@ public GearsOfWarQueryMySqlTest(GearsOfWarQueryMySqlFixture fixture, ITestOutput //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - public override Task DateTimeOffset_Contains_Less_than_Greater_than(bool async) { var dto = MySqlTestHelpers.GetExpectedValue(new DateTimeOffset(599898024001234567, new TimeSpan(1, 30, 0))); @@ -313,10 +310,13 @@ public override async Task Group_by_with_having_StartsWith_with_null_parameter_a AssertSql( """ -SELECT `g`.`FullName` -FROM `Gears` AS `g` -GROUP BY `g`.`FullName` -HAVING FALSE +SELECT `g0`.`FullName` +FROM ( + SELECT `g`.`FullName`, FALSE AS `c` + FROM `Gears` AS `g` + GROUP BY `g`.`FullName`, `c` + HAVING `c` +) AS `g0` """); } @@ -347,12 +347,19 @@ await AssertQuery( where m.Timeline.Hour == /* 10 */ 8 select m); - AssertSql( + AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(hour FROM `m`.`Timeline`) = 8 """); } + + // TODO: Implement once TimeSpan is translated as ticks instead of TIME. + public override async Task Non_string_concat_uses_appropriate_type_mapping(bool async) + { + var exception = await Assert.ThrowsAsync(() => base.Non_string_concat_uses_appropriate_type_mapping(async)); + Assert.Equal("Unable to cast object of type 'System.Decimal' to type 'System.TimeSpan'.", exception.Message); + } } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/JsonMicrosoftDomChangeTrackingTest.cs b/test/EFCore.MySql.FunctionalTests/Query/JsonMicrosoftDomChangeTrackingTest.cs index 07a706f79..b6e928807 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/JsonMicrosoftDomChangeTrackingTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/JsonMicrosoftDomChangeTrackingTest.cs @@ -1,5 +1,6 @@ using System.Linq; using System.Text.Json; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.TestUtilities; @@ -226,7 +227,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) } } - public void Seed() + public async Task SeedAsync() { var (customer1, customer2, customer3) = (CreateCustomer1(), CreateCustomer2(), CreateCustomer3()); @@ -234,7 +235,7 @@ public void Seed() new JsonEntity { Id = 1, CustomerDocument = customer1, CustomerElement = customer1.RootElement }, new JsonEntity { Id = 2, CustomerDocument = customer2, CustomerElement = customer2.RootElement }, new JsonEntity { Id = 3, CustomerDocument = customer3, CustomerElement = customer3.RootElement }); - SaveChanges(); + await SaveChangesAsync(); } public static JsonDocument CreateCustomer1() @@ -324,7 +325,7 @@ public class JsonMicrosoftDomChangeTrackingFixture : ServiceProviderPerContextFi { protected override string StoreName => "JsonMicrosoftDomChangeTrackingTest"; protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; - protected override void Seed(JsonMicrosoftDomChangeTrackingContext context) => context.Seed(); + protected override Task SeedAsync(JsonMicrosoftDomChangeTrackingContext context) => context.SeedAsync(); protected override IServiceCollection AddServices(IServiceCollection serviceCollection) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/JsonMicrosoftDomQueryTest.cs b/test/EFCore.MySql.FunctionalTests/Query/JsonMicrosoftDomQueryTest.cs index 22c4d38bf..b1cf25b17 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/JsonMicrosoftDomQueryTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/JsonMicrosoftDomQueryTest.cs @@ -1,6 +1,7 @@ using System; using System.Linq; using System.Text.Json; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.TestUtilities; @@ -476,7 +477,7 @@ public class JsonDomQueryContext : PoolableDbContext public JsonDomQueryContext(DbContextOptions options) : base(options) {} - public static void Seed(JsonDomQueryContext context) + public static async Task SeedAsync(JsonDomQueryContext context) { var (customer1, customer2, customer3) = (createCustomer1(), createCustomer2(), createCustomer3()); @@ -484,7 +485,7 @@ public static void Seed(JsonDomQueryContext context) new JsonEntity { Id = 1, CustomerDocument = customer1, CustomerElement = customer1.RootElement }, new JsonEntity { Id = 2, CustomerDocument = customer2, CustomerElement = customer2.RootElement }, new JsonEntity { Id = 3, CustomerDocument = customer3, CustomerElement = customer3.RootElement }); - context.SaveChanges(); + await context.SaveChangesAsync(); static JsonDocument createCustomer1() => JsonDocument.Parse(@" { @@ -564,7 +565,7 @@ public class JsonMicrosoftDomQueryFixture : SharedStoreFixtureBase "JsonMicrosoftDomQueryTest"; protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; - protected override void Seed(JsonDomQueryContext context) => JsonDomQueryContext.Seed(context); + protected override Task SeedAsync(JsonDomQueryContext context) => JsonDomQueryContext.SeedAsync(context); protected override IServiceCollection AddServices(IServiceCollection serviceCollection) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/JsonNewtonsoftDomChangeTrackingTest.cs b/test/EFCore.MySql.FunctionalTests/Query/JsonNewtonsoftDomChangeTrackingTest.cs index d5bcf80a0..ea8fff5c8 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/JsonNewtonsoftDomChangeTrackingTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/JsonNewtonsoftDomChangeTrackingTest.cs @@ -1,4 +1,5 @@ using System.Linq; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.TestUtilities; @@ -226,7 +227,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder) } } - public void Seed() + public async Task SeedAsync() { var (customer1, customer2, customer3) = (CreateCustomer1(), CreateCustomer2(), CreateCustomer3()); @@ -234,7 +235,7 @@ public void Seed() new JsonEntity { Id = 1, CustomerJObject = customer1, CustomerJToken = customer1}, new JsonEntity { Id = 2, CustomerJObject = customer2, CustomerJToken = customer2}, new JsonEntity { Id = 3, CustomerJObject = null, CustomerJToken = customer3}); - SaveChanges(); + await SaveChangesAsync(); } public static JObject CreateCustomer1() @@ -324,7 +325,7 @@ public class JsonMicrosoftDomChangeTrackingFixture : ServiceProviderPerContextFi { protected override string StoreName => "JsonNewtonsoftDomChangeTrackingTest"; protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; - protected override void Seed(JsonMicrosoftDomChangeTrackingContext context) => context.Seed(); + protected override Task SeedAsync(JsonMicrosoftDomChangeTrackingContext context) => context.SeedAsync(); protected override IServiceCollection AddServices(IServiceCollection serviceCollection) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/JsonNewtonsoftDomQueryTest.cs b/test/EFCore.MySql.FunctionalTests/Query/JsonNewtonsoftDomQueryTest.cs index 570f0473c..c5ae525c8 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/JsonNewtonsoftDomQueryTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/JsonNewtonsoftDomQueryTest.cs @@ -1,5 +1,6 @@ using System; using System.Linq; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.TestUtilities; @@ -504,7 +505,7 @@ public class JsonDomQueryContext : PoolableDbContext public JsonDomQueryContext(DbContextOptions options) : base(options) {} - public static void Seed(JsonDomQueryContext context) + public static async Task SeedAsync(JsonDomQueryContext context) { var (customer1, customer2, customer3) = (createCustomer1(), createCustomer2(), createCustomer3()); @@ -512,7 +513,7 @@ public static void Seed(JsonDomQueryContext context) new JsonEntity { Id = 1, CustomerJObject = customer1, CustomerJToken = customer1}, new JsonEntity { Id = 2, CustomerJObject = customer2, CustomerJToken = customer2}, new JsonEntity { Id = 3, CustomerJObject = null, CustomerJToken = customer3}); - context.SaveChanges(); + await context.SaveChangesAsync(); static JObject createCustomer1() => JObject.Parse(@" { @@ -592,7 +593,7 @@ public class JsonNewtonsoftDomQueryFixture : SharedStoreFixtureBase "JsonNewtonsoftDomQueryTest"; protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; - protected override void Seed(JsonDomQueryContext context) => JsonDomQueryContext.Seed(context); + protected override Task SeedAsync(JsonDomQueryContext context) => JsonDomQueryContext.SeedAsync(context); protected override IServiceCollection AddServices(IServiceCollection serviceCollection) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/JsonPocoChangeTrackingTestBase.cs b/test/EFCore.MySql.FunctionalTests/Query/JsonPocoChangeTrackingTestBase.cs index 7cd5f8069..e55192a18 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/JsonPocoChangeTrackingTestBase.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/JsonPocoChangeTrackingTestBase.cs @@ -1,6 +1,7 @@ using System; using System.ComponentModel.DataAnnotations.Schema; using System.Linq; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.TestUtilities; @@ -248,12 +249,12 @@ private void SetGlobalJsonChangeTrackingOptions( addOrUpdateExtensionMethod.Invoke(optionsBuilder, new object[] {mySqlJsonOptions}); } - public void Seed() + public async Task SeedAsync() { JsonEntities.AddRange( new JsonEntity { Id = 1, Customer = CreateCustomer1(), ToplevelArray = new[] { "one", "two", "three" } }, new JsonEntity { Id = 2, Customer = CreateCustomer2() }); - SaveChanges(); + await SaveChangesAsync(); } public static Customer CreateCustomer1() @@ -300,7 +301,7 @@ public class JsonPocoChangeTrackingFixtureBase : ServiceProviderPerContextFixtur { protected override string StoreName => "JsonPocoChangeTrackingTest"; protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; - protected override void Seed(JsonPocoChangeTrackingContext context) => context.Seed(); + protected override Task SeedAsync(JsonPocoChangeTrackingContext context) => context.SeedAsync(); public virtual DbContextOptionsBuilder AddOptions(DbContextOptionsBuilder builder, MySqlJsonChangeTrackingOptions? changeTrackingOptions) => builder; diff --git a/test/EFCore.MySql.FunctionalTests/Query/JsonPocoQueryTestBase.cs b/test/EFCore.MySql.FunctionalTests/Query/JsonPocoQueryTestBase.cs index aeca7a48b..ff9b59bf5 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/JsonPocoQueryTestBase.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/JsonPocoQueryTestBase.cs @@ -2,6 +2,7 @@ using System.ComponentModel.DataAnnotations.Schema; using System.Linq; using System.Text.Json.Serialization; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.TestUtilities; using Newtonsoft.Json; @@ -474,12 +475,12 @@ public class JsonPocoQueryContext : PoolableDbContext public JsonPocoQueryContext(DbContextOptions options) : base(options) {} - public static void Seed(JsonPocoQueryContext context) + public static async Task SeedAsync(JsonPocoQueryContext context) { context.JsonEntities.AddRange( new JsonEntity { Id = 1, Customer = createCustomer1(), ToplevelArray = new[] { "one", "two", "three" } }, new JsonEntity { Id = 2, Customer = createCustomer2() }); - context.SaveChanges(); + await context.SaveChangesAsync(); static Customer createCustomer1() => new Customer { @@ -567,7 +568,7 @@ public class JsonPocoQueryFixtureBase : SharedStoreFixtureBase MySqlTestStoreFactory.GuidBinary16Instance; public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; - protected override void Seed(JsonPocoQueryContext context) => JsonPocoQueryContext.Seed(context); + protected override Task SeedAsync(JsonPocoQueryContext context) => JsonPocoQueryContext.SeedAsync(context); } public class Customer diff --git a/test/EFCore.MySql.FunctionalTests/Query/JsonStringChangeTrackingTestBase.cs b/test/EFCore.MySql.FunctionalTests/Query/JsonStringChangeTrackingTestBase.cs index 180f2d066..58953eece 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/JsonStringChangeTrackingTestBase.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/JsonStringChangeTrackingTestBase.cs @@ -1,5 +1,6 @@ using System.ComponentModel.DataAnnotations.Schema; using System.Linq; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.TestUtilities; @@ -293,12 +294,12 @@ private void SetGlobalJsonChangeTrackingOptions( addOrUpdateExtensionMethod.Invoke(optionsBuilder, new object[] {mySqlJsonOptions}); } - public void Seed() + public async Task SeedAsync() { JsonEntities.AddRange( new JsonEntity {Id = 1, Customer = Customer1}, new JsonEntity {Id = 2, Customer = Customer2}); - SaveChanges(); + await SaveChangesAsync(); } public class JsonPocoChangeTrackingContextOptions @@ -320,7 +321,7 @@ public class JsonStringChangeTrackingFixtureBase : ServiceProviderPerContextFixt { protected override string StoreName => "JsonStringChangeTrackingTest"; protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; - protected override void Seed(JsonStringChangeTrackingContext context) => context.Seed(); + protected override Task SeedAsync(JsonStringChangeTrackingContext context) => context.SeedAsync(); public virtual DbContextOptionsBuilder AddOptions(DbContextOptionsBuilder builder, MySqlJsonChangeTrackingOptions? changeTrackingOptions) => builder; diff --git a/test/EFCore.MySql.FunctionalTests/Query/JsonStringQueryTestBase.cs b/test/EFCore.MySql.FunctionalTests/Query/JsonStringQueryTestBase.cs index 30d640db6..7f7757591 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/JsonStringQueryTestBase.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/JsonStringQueryTestBase.cs @@ -2,6 +2,7 @@ using System.ComponentModel.DataAnnotations.Schema; using System.Linq; using System.Text.Json; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; @@ -243,7 +244,7 @@ public class JsonStringQueryContext : PoolableDbContext public JsonStringQueryContext(DbContextOptions options) : base(options) {} - public static void Seed(JsonStringQueryContext context) + public static async Task SeedAsync(JsonStringQueryContext context) { const string customer1 = @" { @@ -303,7 +304,7 @@ public static void Seed(JsonStringQueryContext context) context.JsonEntities.AddRange( new JsonEntity { Id = 1, CustomerJson = customer1 }, new JsonEntity { Id = 2, CustomerJson = customer2 }); - context.SaveChanges(); + await context.SaveChangesAsync(); } } @@ -320,7 +321,7 @@ public class JsonStringQueryFixtureBase : SharedStoreFixtureBase "JsonStringQueryTest"; protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; - protected override void Seed(JsonStringQueryContext context) => JsonStringQueryContext.Seed(context); + protected override Task SeedAsync(JsonStringQueryContext context) => JsonStringQueryContext.SeedAsync(context); } #endregion diff --git a/test/EFCore.MySql.FunctionalTests/Query/ManyToManyFieldsLoadMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/ManyToManyFieldsLoadMySqlTest.cs index 970a5467b..3baaaa582 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/ManyToManyFieldsLoadMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/ManyToManyFieldsLoadMySqlTest.cs @@ -14,7 +14,7 @@ public ManyToManyFieldsLoadMySqlTest(ManyToManyFieldsLoadMySqlFixture fixture) { } - public class ManyToManyFieldsLoadMySqlFixture : ManyToManyFieldsLoadFixtureBase + public class ManyToManyFieldsLoadMySqlFixture : ManyToManyFieldsLoadFixtureBase, ITestSqlLoggerFactory { public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; diff --git a/test/EFCore.MySql.FunctionalTests/Query/ManyToManyNoTrackingQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/ManyToManyNoTrackingQueryMySqlTest.cs index 52b19dc62..c08f85ce2 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/ManyToManyNoTrackingQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/ManyToManyNoTrackingQueryMySqlTest.cs @@ -12,8 +12,5 @@ public ManyToManyNoTrackingQueryMySqlTest(ManyToManyQueryMySqlFixture fixture, I Fixture.TestSqlLoggerFactory.Clear(); //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - - protected override bool CanExecuteQueryString - => true; } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/ManyToManyQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/ManyToManyQueryMySqlTest.cs index 1b8dce72c..4f7364f4e 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/ManyToManyQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/ManyToManyQueryMySqlTest.cs @@ -10,8 +10,5 @@ public ManyToManyQueryMySqlTest(ManyToManyQueryMySqlFixture fixture, ITestOutput { Fixture.TestSqlLoggerFactory.Clear(); } - - protected override bool CanExecuteQueryString - => true; } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/MatchQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/MatchQueryMySqlTest.cs index 910c774f4..de8e829eb 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/MatchQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/MatchQueryMySqlTest.cs @@ -527,7 +527,7 @@ protected MatchQueryMySqlTestBase(TFixture fixture) protected virtual DbContext CreateContext() => Fixture.CreateContext(); - public abstract class MatchQueryMySqlFixtureBase : SharedStoreFixtureBase, IQueryFixtureBase + public abstract class MatchQueryMySqlFixtureBase : SharedStoreFixtureBase, IQueryFixtureBase, ITestSqlLoggerFactory { protected override string StoreName { get; } = "MatchQueryTest"; public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; diff --git a/test/EFCore.MySql.FunctionalTests/Query/NonSharedPrimitiveCollectionsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NonSharedPrimitiveCollectionsQueryMySqlTest.cs index a72131386..ff692781c 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NonSharedPrimitiveCollectionsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NonSharedPrimitiveCollectionsQueryMySqlTest.cs @@ -1,8 +1,11 @@ using System; using System.Threading.Tasks; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; +using Pomelo.EntityFrameworkCore.MySql.Internal; using Pomelo.EntityFrameworkCore.MySql.Tests; using Xunit; @@ -378,10 +381,6 @@ LIMIT 2 """); } - [ConditionalFact] - public override Task Array_of_array_is_not_supported() - => base.Array_of_array_is_not_supported(); - [ConditionalFact] public override Task Multidimensional_array_is_not_supported() => base.Multidimensional_array_is_not_supported(); @@ -474,38 +473,123 @@ LIMIT 2 public override async Task Column_collection_inside_json_owned_entity() { - await base.Column_collection_inside_json_owned_entity(); + var exception = await Assert.ThrowsAsync(() => base.Column_collection_inside_json_owned_entity()); + Assert.Equal(MySqlStrings.Ef7CoreJsonMappingNotSupported, exception.Message); + } + + #endregion Type mapping inference + + public override async Task Parameter_collection_Count_with_column_predicate_with_default_constants() + { + await base.Parameter_collection_Count_with_column_predicate_with_default_constants(); AssertSql( - """ -SELECT TOP(2) [t].[Id], [t].[Owned] -FROM [TestOwner] AS [t] +$""" +SELECT `t`.`Id` +FROM `TestEntity` AS `t` WHERE ( SELECT COUNT(*) - FROM OPENJSON(JSON_VALUE([t].[Owned], '$.Strings')) AS [s]) = 2 -""", - // - """ -SELECT TOP(2) [t].[Id], [t].[Owned] -FROM [TestOwner] AS [t] -WHERE JSON_VALUE(JSON_VALUE([t].[Owned], '$.Strings'), '$[1]') = N'bar' + FROM (SELECT 2 AS `Value` UNION ALL VALUES {(AppConfig.ServerVersion.Supports.ValuesWithRows ? "ROW" : string.Empty)}(999)) AS `i` + WHERE `i`.`Value` > `t`.`Id`) = 1 """); } - #endregion Type mapping inference + public override async Task Parameter_collection_of_ints_Contains_int_with_default_constants() + { + await base.Parameter_collection_of_ints_Contains_int_with_default_constants(); - [ConditionalFact] - public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + AssertSql( +""" +SELECT `t`.`Id` +FROM `TestEntity` AS `t` +WHERE `t`.`Id` IN (2, 999) +"""); + } - protected override ITestStoreFactory TestStoreFactory - => MySqlTestStoreFactory.Instance; -} + public override async Task Parameter_collection_Count_with_column_predicate_with_default_constants_EF_Parameter() + { + await base.Parameter_collection_Count_with_column_predicate_with_default_constants_EF_Parameter(); + + AssertSql(); + } + + public override async Task Parameter_collection_of_ints_Contains_int_with_default_constants_EF_Parameter() + { + await base.Parameter_collection_of_ints_Contains_int_with_default_constants_EF_Parameter(); + + AssertSql(); + } + + public override async Task Parameter_collection_Count_with_column_predicate_with_default_parameters() + { + await base.Parameter_collection_Count_with_column_predicate_with_default_parameters(); + + AssertSql(); + } + + public override async Task Parameter_collection_of_ints_Contains_int_with_default_parameters() + { + await base.Parameter_collection_of_ints_Contains_int_with_default_parameters(); + AssertSql(); + } + public override async Task Parameter_collection_Count_with_column_predicate_with_default_parameters_EF_Constant() + { + await base.Parameter_collection_Count_with_column_predicate_with_default_parameters_EF_Constant(); + AssertSql( +$""" +SELECT `t`.`Id` +FROM `TestEntity` AS `t` +WHERE ( + SELECT COUNT(*) + FROM (SELECT 2 AS `Value` UNION ALL VALUES {(AppConfig.ServerVersion.Supports.ValuesWithRows ? "ROW" : string.Empty)}(999)) AS `i` + WHERE `i`.`Value` > `t`.`Id`) = 1 +"""); + } + public override async Task Parameter_collection_of_ints_Contains_int_with_default_parameters_EF_Constant() + { + await base.Parameter_collection_of_ints_Contains_int_with_default_parameters_EF_Constant(); + AssertSql( +""" +SELECT `t`.`Id` +FROM `TestEntity` AS `t` +WHERE `t`.`Id` IN (2, 999) +"""); + } + public override async Task Project_collection_from_entity_type_with_owned() + { + await base.Project_collection_from_entity_type_with_owned(); + AssertSql( +""" +SELECT `t`.`Ints` +FROM `TestEntityWithOwned` AS `t` +"""); + } + + [ConditionalFact] + public virtual void Check_all_tests_overridden() + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); + + protected override DbContextOptionsBuilder SetTranslateParameterizedCollectionsToConstants(DbContextOptionsBuilder optionsBuilder) + { + new MySqlDbContextOptionsBuilder(optionsBuilder).TranslateParameterizedCollectionsToConstants(); + + return optionsBuilder; + } + + protected override DbContextOptionsBuilder SetTranslateParameterizedCollectionsToParameters(DbContextOptionsBuilder optionsBuilder) + { + new MySqlDbContextOptionsBuilder(optionsBuilder).TranslateParameterizedCollectionsToParameters(); + + return optionsBuilder; + } + protected override ITestStoreFactory TestStoreFactory + => MySqlTestStoreFactory.Instance; +} diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindAggregateOperatorsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindAggregateOperatorsQueryMySqlTest.cs index 33169eb8d..b477be8db 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindAggregateOperatorsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindAggregateOperatorsQueryMySqlTest.cs @@ -21,14 +21,14 @@ public NorthwindAggregateOperatorsQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - public override Task Average_over_max_subquery_is_client_eval(bool async) + public override Task Average_over_max_subquery(bool async) => AssertAverage( async, ss => ss.Set().OrderBy(c => c.CustomerID).Take(3), selector: c => (decimal)c.Orders.Average(o => 5 + o.OrderDetails.Max(od => od.ProductID)), asserter: (a, b) => Assert.Equal(a, b, 12)); // added flouting point precision tolerance - public override Task Average_over_nested_subquery_is_client_eval(bool async) + public override Task Average_over_nested_subquery(bool async) => AssertAverage( async, ss => ss.Set().OrderBy(c => c.CustomerID).Take(3), @@ -79,9 +79,6 @@ await Assert.ThrowsAsync( AssertSql(); } - protected override bool CanExecuteQueryString - => true; - private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindEFPropertyIncludeQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindEFPropertyIncludeQueryMySqlTest.cs index aa686f551..a688fda27 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindEFPropertyIncludeQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindEFPropertyIncludeQueryMySqlTest.cs @@ -24,7 +24,7 @@ public NorthwindEFPropertyIncludeQueryMySqlTest(NorthwindQueryMySqlFixture TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Include_collection_with_last_no_orderby(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.MySql.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.MySql.cs index e33025dc2..d864f3a6d 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.MySql.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.MySql.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Linq; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.TestModels.Northwind; @@ -63,745 +63,6 @@ await AssertQuery( WHERE RPAD(`c`.`CustomerID`, 8, 'c') = 'ALFKIccc'"); } - [ConditionalTheory] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.Ordinal, 0, false)] - [InlineData(StringComparison.Ordinal, 0, true)] - [InlineData(StringComparison.CurrentCulture, 0, false)] - [InlineData(StringComparison.CurrentCulture, 0, true)] - [InlineData(StringComparison.InvariantCulture, 0, false)] - [InlineData(StringComparison.InvariantCulture, 0, true)] - public async Task StringEquals_with_comparison_parameter(StringComparison comparison, int expected, bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Equals("anton", comparison)), - assertEmpty: expected == 0); - - // When the comparison parameter is not a constant, we have to use a case - // statement - AssertSql( - $@"@__comparison_0='{comparison:D}' - -SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE CASE - WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin - ELSE (LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin) AND CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin IS NOT NULL -END"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEquals_ordinal(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.Ordinal)), - assertEmpty: true); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEquals_invariant(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.CurrentCulture)), - assertEmpty: true); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEquals_current(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.InvariantCulture)), - assertEmpty: true); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEquals_ordinal_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.OrdinalIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEquals_current_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.CurrentCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEquals_invariant_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.InvariantCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.Ordinal, 0, false)] - [InlineData(StringComparison.Ordinal, 0, true)] - [InlineData(StringComparison.CurrentCulture, 0, false)] - [InlineData(StringComparison.CurrentCulture, 0, true)] - [InlineData(StringComparison.InvariantCulture, 0, false)] - [InlineData(StringComparison.InvariantCulture, 0, true)] - public async Task StaticStringEquals_with_comparison(StringComparison comparison, int expected, bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", comparison)), - assertEmpty: expected == 0); - - // When the comparison parameter is not a constant, we have to use a case - // statement - AssertSql( - $@"@__comparison_0='{comparison:D}' - -SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE CASE - WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin - ELSE (LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin) AND CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin IS NOT NULL -END"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StaticStringEquals_ordinal(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.Ordinal)), - assertEmpty: true); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StaticStringEquals_invariant(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.CurrentCulture)), - assertEmpty: true); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StaticStringEquals_current(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.InvariantCulture)), - assertEmpty: true); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StaticStringEquals_ordinal_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.OrdinalIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StaticStringEquals_current_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.CurrentCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StaticStringEquals_invariant_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.InvariantCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.Ordinal, 0, false)] - [InlineData(StringComparison.Ordinal, 0, true)] - [InlineData(StringComparison.CurrentCulture, 0, false)] - [InlineData(StringComparison.CurrentCulture, 0, true)] - [InlineData(StringComparison.InvariantCulture, 0, false)] - [InlineData(StringComparison.InvariantCulture, 0, true)] - public async Task StringContains_with_comparison(StringComparison comparison, int expected, bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Contains("nto", comparison)), - assertEmpty: expected == 0); - - // When the comparison parameter is not a constant, we have to use a case - // statement - AssertSql( - $@"@__comparison_0='{comparison:D}' - -SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE CASE - WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` LIKE CONVERT('%nto%' USING utf8mb4) COLLATE utf8mb4_bin - ELSE ((LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nto%') USING utf8mb4) COLLATE utf8mb4_bin) AND TRUE) AND CONVERT(LCASE('%nto%') USING utf8mb4) COLLATE utf8mb4_bin IS NOT NULL -END"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringContains_ordinal(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.Ordinal)), - assertEmpty: true); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` LIKE CONVERT('%nto%' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringContains_invariant(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.CurrentCulture)), - assertEmpty: true); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` LIKE CONVERT('%nto%' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringContains_current(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.InvariantCulture)), - assertEmpty: true); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` LIKE CONVERT('%nto%' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringContains_ordinal_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.OrdinalIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nto%') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringContains_current_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.CurrentCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nto%') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringContains_invariant_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.InvariantCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nto%') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.Ordinal, 0, false)] - [InlineData(StringComparison.Ordinal, 0, true)] - [InlineData(StringComparison.CurrentCulture, 0, false)] - [InlineData(StringComparison.CurrentCulture, 0, true)] - [InlineData(StringComparison.InvariantCulture, 0, false)] - [InlineData(StringComparison.InvariantCulture, 0, true)] - public async Task StringStartsWith_with_comparison(StringComparison comparison, int expected, bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", comparison)), - assertEmpty: expected == 0); - - // When the comparison parameter is not a constant, we have to use a case - // statement - AssertSql( - $@"@__comparison_0='{comparison:D}' - -SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE CASE - WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` LIKE CONVERT('anto' USING utf8mb4) COLLATE utf8mb4_bin - ELSE ((LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('anto%') USING utf8mb4) COLLATE utf8mb4_bin) AND TRUE) AND CONVERT(LCASE('anto%') USING utf8mb4) COLLATE utf8mb4_bin IS NOT NULL -END"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringStartsWith_ordinal(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.Ordinal)), - assertEmpty: true); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` LIKE CONVERT('anto%' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringStartsWith_invariant(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.CurrentCulture)), - assertEmpty: true); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` LIKE CONVERT('anto%' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringStartsWith_current(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.InvariantCulture)), - assertEmpty: true); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` LIKE CONVERT('anto%' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringStartsWith_ordinal_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.OrdinalIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(LCASE(`c`.`CustomerID`)) LIKE CONVERT(LCASE('anto%') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringStartsWith_current_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.CurrentCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(LCASE(`c`.`CustomerID`)) LIKE CONVERT(LCASE('anto%') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringStartsWith_invariant_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.InvariantCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(LCASE(`c`.`CustomerID`)) LIKE CONVERT(LCASE('anto%') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.Ordinal, 0, false)] - [InlineData(StringComparison.Ordinal, 0, true)] - [InlineData(StringComparison.CurrentCulture, 0, false)] - [InlineData(StringComparison.CurrentCulture, 0, true)] - [InlineData(StringComparison.InvariantCulture, 0, false)] - [InlineData(StringComparison.InvariantCulture, 0, true)] - public async Task StringEndsWith_with_comparison(StringComparison comparison, int expected, bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", comparison)), - assertEmpty: expected == 0); - - AssertSql( - $@"@__comparison_0='{comparison:D}' - -SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE CASE - WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` LIKE CONVERT('%nton' USING utf8mb4) COLLATE utf8mb4_bin - ELSE ((LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nton') USING utf8mb4) COLLATE utf8mb4_bin) AND TRUE) AND CONVERT(LCASE('%nton') USING utf8mb4) COLLATE utf8mb4_bin IS NOT NULL -END"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEndsWith_ordinal(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.Ordinal)), - assertEmpty: true); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` LIKE CONVERT('%nton' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEndsWith_invariant(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.CurrentCulture)), - assertEmpty: true); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` LIKE CONVERT('%nton' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEndsWith_current(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.InvariantCulture)), - assertEmpty: true); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE `c`.`CustomerID` LIKE CONVERT('%nton' USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEndsWith_ordinal_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.OrdinalIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nton') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEndsWith_current_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.CurrentCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nton') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringEndsWith_invariant_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.InvariantCultureIgnoreCase))); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nton') USING utf8mb4) COLLATE utf8mb4_bin"); - } - - [ConditionalTheory] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] - [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] - [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] - [InlineData(StringComparison.Ordinal, 0, false)] - [InlineData(StringComparison.Ordinal, 0, true)] - [InlineData(StringComparison.CurrentCulture, 0, false)] - [InlineData(StringComparison.CurrentCulture, 0, true)] - [InlineData(StringComparison.InvariantCulture, 0, false)] - [InlineData(StringComparison.InvariantCulture, 0, true)] - public async Task StringIndexOf_with_comparison(StringComparison comparison, int expected, bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", comparison) == 1), - assertEmpty: expected == 0); - - // When the comparison parameter is not a constant, we have to use a case - // statement - AssertSql($"@__comparison_0='{comparison:D}'" + @" - -SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE CASE - WHEN @__comparison_0 IN (4, 0, 2) THEN LOCATE(CONVERT('nt' USING utf8mb4) COLLATE utf8mb4_bin, `c`.`CustomerID`) - 1 - ELSE LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`)) - 1 -END = 1"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringIndexOf_with_constant_start_index(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", 0, StringComparison.OrdinalIgnoreCase) == 1)); - - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`), 1) - 1) = 1"); - } - - [ConditionalTheory] - [InlineData(0, 1, false)] - [InlineData(2, 0, false)] - [InlineData(0, 1, true)] - [InlineData(2, 0, true)] - public async Task StringIndexOf_with_parameter_start_index(int startIndex, int expected, bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", startIndex, StringComparison.OrdinalIgnoreCase) == 1), - assertEmpty: expected == 0); - - AssertSql( - @$"@__startIndex_0='{startIndex}' - -SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`), @__startIndex_0 + 1) - 1) = 1"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringIndexOf_ordinal(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.Ordinal) == 1), - assertEmpty: true); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE (LOCATE(CONVERT('nt' USING utf8mb4) COLLATE utf8mb4_bin, `c`.`CustomerID`) - 1) = 1"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringIndexOf_invariant(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.InvariantCulture) == 1), - assertEmpty: true); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE (LOCATE(CONVERT('nt' USING utf8mb4) COLLATE utf8mb4_bin, `c`.`CustomerID`) - 1) = 1"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringIndexOf_current(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.CurrentCulture) == 1), - assertEmpty: true); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE (LOCATE(CONVERT('nt' USING utf8mb4) COLLATE utf8mb4_bin, `c`.`CustomerID`) - 1) = 1"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringIndexOf_ordinal_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.OrdinalIgnoreCase) == 1)); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`)) - 1) = 1"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringIndexOf_current_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.CurrentCultureIgnoreCase) == 1)); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`)) - 1) = 1"); - } - - [ConditionalTheory] - [MemberData(nameof(IsAsyncData))] - public async Task StringIndexOf_invariant_ignore_case(bool async) - { - await AssertQuery( - async, - ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.InvariantCultureIgnoreCase) == 1)); - - AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` -FROM `Customers` AS `c` -WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`)) - 1) = 1"); - } - [ConditionalTheory] [MemberData(nameof(IsAsyncData))] public virtual async Task Where_math_log_new_base2(bool async) @@ -813,10 +74,10 @@ await AssertQueryScalar( AssertSql( $""" -SELECT LOG(7.0, {MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) -FROM `Order Details` AS `o` -WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7.0, {MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) < -1.0) -"""); + SELECT LOG(7.0, {MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) + FROM `Order Details` AS `o` + WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7.0, {MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) < -1.0) + """); } } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.cs index b9c7d15c2..767fb6783 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindFunctionsQueryMySqlTest.cs @@ -20,9 +20,6 @@ public NorthwindFunctionsQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - [ConditionalTheory] public override async Task String_StartsWith_Literal(bool async) { @@ -133,7 +130,7 @@ public override async Task String_Contains_Literal(bool async) await base.String_Contains_Literal(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`ContactName` LIKE '%M%'"); } @@ -156,11 +153,11 @@ public override async Task String_Contains_Column(bool async) { await base.String_Contains_Column(async); - AssertSql( + AssertSql( """ SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` -WHERE `c`.`ContactName` IS NOT NULL AND ((LOCATE(`c`.`ContactName`, `c`.`ContactName`) > 0) OR (`c`.`ContactName` LIKE '')) +WHERE `c`.`ContactName` IS NOT NULL AND ((LOCATE(`c`.`ContactName`, `c`.`CompanyName`) > 0) OR (`c`.`ContactName` LIKE '')) """); } @@ -170,7 +167,7 @@ public override async Task String_Contains_MethodCall(bool async) await base.String_Contains_MethodCall(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`ContactName` LIKE '%M%'"); } @@ -181,7 +178,7 @@ public override async Task IsNullOrWhiteSpace_in_predicate(bool async) await base.IsNullOrWhiteSpace_in_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`Region` IS NULL OR (TRIM(`c`.`Region`) = '')"); } @@ -191,10 +188,12 @@ public override async Task Indexof_with_emptystring(bool async) { await base.Indexof_with_emptystring(async); - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` -WHERE (LOCATE('', `c`.`ContactName`) - 1) = 0"); +WHERE (LOCATE('', `c`.`Region`) - 1) = 0 +"""); } [ConditionalTheory] @@ -249,7 +248,7 @@ public override async Task Substring_with_two_args_with_zero_startindex(bool asy await base.Substring_with_two_args_with_zero_startindex(async); AssertSql( - $@"SELECT SUBSTRING(`c`.`ContactName`, 0 + 1, 3) + @"SELECT SUBSTRING(`c`.`ContactName`, 0 + 1, 3) FROM `Customers` AS `c` WHERE `c`.`CustomerID` = 'ALFKI'"); } @@ -260,7 +259,7 @@ public override async Task Substring_with_two_args_with_zero_length(bool async) await base.Substring_with_two_args_with_zero_length(async); AssertSql( - $@"SELECT SUBSTRING(`c`.`ContactName`, 2 + 1, 0) + @"SELECT SUBSTRING(`c`.`ContactName`, 2 + 1, 0) FROM `Customers` AS `c` WHERE `c`.`CustomerID` = 'ALFKI'"); } @@ -271,7 +270,7 @@ public override async Task Substring_with_two_args_with_constant(bool async) await base.Substring_with_two_args_with_constant(async); AssertSql( - $@"SELECT SUBSTRING(`c`.`ContactName`, 1 + 1, 3) + @"SELECT SUBSTRING(`c`.`ContactName`, 1 + 1, 3) FROM `Customers` AS `c` WHERE `c`.`CustomerID` = 'ALFKI'"); } @@ -282,7 +281,7 @@ public override async Task Substring_with_two_args_with_closure(bool async) await base.Substring_with_two_args_with_closure(async); AssertSql( - $@"@__start_0='2' + @"@__start_0='2' SELECT SUBSTRING(`c`.`ContactName`, @__start_0 + 1, 3) FROM `Customers` AS `c` @@ -295,7 +294,7 @@ public override async Task Substring_with_two_args_with_Index_of(bool async) await base.Substring_with_two_args_with_Index_of(async); AssertSql( - $@"SELECT SUBSTRING(`c`.`ContactName`, (LOCATE('a', `c`.`ContactName`) - 1) + 1, 3) + @"SELECT SUBSTRING(`c`.`ContactName`, (LOCATE('a', `c`.`ContactName`) - 1) + 1, 3) FROM `Customers` AS `c` WHERE `c`.`CustomerID` = 'ALFKI'"); } @@ -373,7 +372,7 @@ public override async Task Where_math_min(bool async) await base.Where_math_min(async); AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` + @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` FROM `Order Details` AS `o` WHERE (`o`.`OrderID` = 11077) AND (LEAST(`o`.`OrderID`, `o`.`ProductID`) = `o`.`ProductID`)"); } @@ -384,7 +383,7 @@ public override async Task Where_math_max(bool async) await base.Where_math_max(async); AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` + @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` FROM `Order Details` AS `o` WHERE (`o`.`OrderID` = 11077) AND (GREATEST(`o`.`OrderID`, `o`.`ProductID`) = `o`.`OrderID`)"); } @@ -395,7 +394,7 @@ public override async Task Where_string_to_lower(bool async) await base.Where_string_to_lower(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE LOWER(`c`.`CustomerID`) = 'alfki'"); } @@ -406,7 +405,7 @@ public override async Task Where_string_to_upper(bool async) await base.Where_string_to_upper(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE UPPER(`c`.`CustomerID`) = 'ALFKI'"); } @@ -417,7 +416,7 @@ public override async Task TrimStart_without_arguments_in_predicate(bool async) await base.TrimStart_without_arguments_in_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE TRIM(LEADING FROM `c`.`ContactTitle`) = 'Owner'"); } @@ -428,7 +427,7 @@ public override async Task TrimStart_with_char_argument_in_predicate(bool async) await base.TrimStart_with_char_argument_in_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE TRIM(LEADING 'O' FROM `c`.`ContactTitle`) = 'wner'"); } @@ -448,7 +447,7 @@ public override async Task TrimEnd_without_arguments_in_predicate(bool async) await base.TrimEnd_without_arguments_in_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE TRIM(TRAILING FROM `c`.`ContactTitle`) = 'Owner'"); } @@ -459,7 +458,7 @@ public override async Task TrimEnd_with_char_argument_in_predicate(bool async) await base.TrimEnd_with_char_argument_in_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE TRIM(TRAILING 'r' FROM `c`.`ContactTitle`) = 'Owne'"); } @@ -479,7 +478,7 @@ public override async Task Trim_without_argument_in_predicate(bool async) await base.Trim_without_argument_in_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE TRIM(`c`.`ContactTitle`) = 'Owner'"); } @@ -490,7 +489,7 @@ public override async Task Trim_with_char_argument_in_predicate(bool async) await base.Trim_with_char_argument_in_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE TRIM('O' FROM `c`.`ContactTitle`) = 'wner'"); } @@ -509,7 +508,7 @@ public override async Task String_FirstOrDefault_MethodCall(bool async) await base.String_FirstOrDefault_MethodCall(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE SUBSTRING(`c`.`ContactName`, 1, 1) = 'A'"); } @@ -519,7 +518,7 @@ public override async Task String_Contains_constant_with_whitespace(bool async) await base.String_Contains_constant_with_whitespace(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`ContactName` LIKE '% %'"); } @@ -543,7 +542,7 @@ public override async Task String_LastOrDefault_MethodCall(bool async) await base.String_LastOrDefault_MethodCall(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE SUBSTRING(`c`.`ContactName`, CHAR_LENGTH(`c`.`ContactName`), 1) = 's'"); } @@ -623,7 +622,7 @@ public override async Task Where_math_round2(bool async) await base.Where_math_round2(async); AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` + @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` FROM `Order Details` AS `o` WHERE ROUND(`o`.`UnitPrice`, 2) > 100.0"); } @@ -675,7 +674,7 @@ public override async Task Where_math_log_new_base(bool async) AssertSql( $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` FROM `Order Details` AS `o` -WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7.0, {MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) < 0.0)"); +WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7.0, {MySqlTestHelpers.CastAsDouble("`o`.`Discount`")}) < -1.0)"); } public override async Task Where_math_sqrt(bool async) @@ -763,7 +762,7 @@ public override async Task Where_math_sign(bool async) await base.Where_math_sign(async); AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` + @"SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` FROM `Order Details` AS `o` WHERE (`o`.`OrderID` = 11077) AND (SIGN(`o`.`Discount`) > 0)"); } @@ -793,7 +792,7 @@ public override async Task IsNullOrEmpty_in_predicate(bool async) await base.IsNullOrEmpty_in_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`Region` IS NULL OR (`c`.`Region` = '')"); } @@ -813,7 +812,7 @@ public override async Task IsNullOrWhiteSpace_in_predicate_on_non_nullable_colum await base.IsNullOrWhiteSpace_in_predicate_on_non_nullable_column(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE TRIM(`c`.`CustomerID`) = ''"); } @@ -823,7 +822,7 @@ public override async Task Order_by_length_twice(bool async) await base.Order_by_length_twice(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` ORDER BY CHAR_LENGTH(`c`.`CustomerID`), `c`.`CustomerID`"); } @@ -833,7 +832,7 @@ public override async Task Order_by_length_twice_followed_by_projection_of_naked await base.Order_by_length_twice_followed_by_projection_of_naked_collection_navigation(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + @"SELECT `c`.`CustomerID`, `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Customers` AS `c` LEFT JOIN `Orders` AS `o` ON `c`.`CustomerID` = `o`.`CustomerID` ORDER BY CHAR_LENGTH(`c`.`CustomerID`), `c`.`CustomerID`"); @@ -844,7 +843,7 @@ public override async Task Static_string_equals_in_predicate(bool async) await base.Static_string_equals_in_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`CustomerID` = 'ANATR'"); } @@ -854,7 +853,7 @@ public override async Task Static_equals_nullable_datetime_compared_to_non_nulla await base.Static_equals_nullable_datetime_compared_to_non_nullable(async); AssertSql( - $@"@__arg_0='1996-07-04T00:00:00.0000000' (DbType = DateTime) + @"@__arg_0='1996-07-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` @@ -866,7 +865,7 @@ public override async Task Static_equals_int_compared_to_long(bool async) await base.Static_equals_int_compared_to_long(async); AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + @"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE FALSE"); } @@ -1047,7 +1046,7 @@ public override async Task String_Compare_simple_more_than_one(bool async) await base.String_Compare_simple_more_than_one(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE CASE WHEN `c`.`CustomerID` = 'ALFKI' THEN 0 @@ -1055,7 +1054,7 @@ WHERE CASE WHEN `c`.`CustomerID` < 'ALFKI' THEN -1 END = 42", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE CASE WHEN `c`.`CustomerID` = 'ALFKI' THEN 0 @@ -1063,7 +1062,7 @@ WHERE CASE WHEN `c`.`CustomerID` < 'ALFKI' THEN -1 END > 42", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE 42 > CASE WHEN `c`.`CustomerID` = 'ALFKI' THEN 0 @@ -1077,27 +1076,27 @@ public override async Task String_Compare_nested(bool async) await base.String_Compare_nested(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`CustomerID` = (CONCAT('M', `c`.`CustomerID`))", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`CustomerID` <> UPPER(`c`.`CustomerID`)", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`CustomerID` > REPLACE('ALFKI', 'ALF', `c`.`CustomerID`)", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`CustomerID` <= (CONCAT('M', `c`.`CustomerID`))", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`CustomerID` > UPPER(`c`.`CustomerID`)", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE `c`.`CustomerID` < REPLACE('ALFKI', 'ALF', `c`.`CustomerID`)"); } @@ -1107,11 +1106,11 @@ public override async Task String_Compare_multi_predicate(bool async) await base.String_Compare_multi_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE (`c`.`CustomerID` >= 'ALFKI') AND (`c`.`CustomerID` < 'CACTU')", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE (`c`.`ContactTitle` = 'Owner') AND ((`c`.`Country` <> 'USA') OR `c`.`Country` IS NULL)"); } @@ -1259,7 +1258,7 @@ public override async Task String_Compare_to_simple_more_than_one(bool async) await base.String_Compare_to_simple_more_than_one(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE CASE WHEN `c`.`CustomerID` = 'ALFKI' THEN 0 @@ -1267,7 +1266,7 @@ WHERE CASE WHEN `c`.`CustomerID` < 'ALFKI' THEN -1 END = 42", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE CASE WHEN `c`.`CustomerID` = 'ALFKI' THEN 0 @@ -1275,7 +1274,7 @@ WHERE CASE WHEN `c`.`CustomerID` < 'ALFKI' THEN -1 END > 42", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE 42 > CASE WHEN `c`.`CustomerID` = 'ALFKI' THEN 0 @@ -1331,11 +1330,11 @@ public override async Task String_Compare_to_multi_predicate(bool async) await base.String_Compare_to_multi_predicate(async); AssertSql( - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE (`c`.`CustomerID` >= 'ALFKI') AND (`c`.`CustomerID` < 'CACTU')", // - $@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` WHERE (`c`.`ContactTitle` = 'Owner') AND ((`c`.`Country` <> 'USA') OR `c`.`Country` IS NULL)"); } @@ -1345,37 +1344,37 @@ public override async Task DateTime_Compare_to_simple_zero(bool async, bool comp await base.DateTime_Compare_to_simple_zero(async, compareTo); AssertSql( - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderDate` = @__myDatetime_0", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE (`o`.`OrderDate` <> @__myDatetime_0) OR `o`.`OrderDate` IS NULL", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderDate` > @__myDatetime_0", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderDate` <= @__myDatetime_0", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderDate` > @__myDatetime_0", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` @@ -1387,37 +1386,37 @@ public override async Task TimeSpan_Compare_to_simple_zero(bool async, bool comp await base.TimeSpan_Compare_to_simple_zero(async, compareTo); AssertSql( - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderDate` = @__myDatetime_0", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE (`o`.`OrderDate` <> @__myDatetime_0) OR `o`.`OrderDate` IS NULL", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderDate` > @__myDatetime_0", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderDate` <= @__myDatetime_0", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderDate` > @__myDatetime_0", // - $@"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) + @"@__myDatetime_0='1998-05-04T00:00:00.0000000' (DbType = DateTime) SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` @@ -1429,37 +1428,37 @@ public override async Task Int_Compare_to_simple_zero(bool async) await base.Int_Compare_to_simple_zero(async); AssertSql( - $@"@__orderId_0='10250' + @"@__orderId_0='10250' SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderID` = @__orderId_0", // - $@"@__orderId_0='10250' + @"@__orderId_0='10250' SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderID` <> @__orderId_0", // - $@"@__orderId_0='10250' + @"@__orderId_0='10250' SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderID` > @__orderId_0", // - $@"@__orderId_0='10250' + @"@__orderId_0='10250' SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderID` <= @__orderId_0", // - $@"@__orderId_0='10250' + @"@__orderId_0='10250' SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` WHERE `o`.`OrderID` > @__orderId_0", // - $@"@__orderId_0='10250' + @"@__orderId_0='10250' SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` @@ -1470,122 +1469,192 @@ public override async Task Convert_ToBoolean(bool async) { await base.Convert_ToBoolean(async); - AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(`o`.`OrderID` % 3 AS signed)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(`o`.`OrderID` % 3 AS signed) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(CAST(`o`.`OrderID` % 3 AS unsigned) AS signed)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(CAST(`o`.`OrderID` % 3 AS unsigned) AS signed) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(CAST(`o`.`OrderID` % 3 AS decimal(65,30)) AS signed)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(CAST(`o`.`OrderID` % 3 AS decimal(65,30)) AS signed) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 3")} AS signed)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(CAST(`o`.`OrderID` % 3 AS double) AS signed) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 3")} AS signed)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(CAST(`o`.`OrderID` % 3 AS double) AS signed) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(`o`.`OrderID` % 3 AS signed)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(`o`.`OrderID` % 3 AS signed) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(`o`.`OrderID` % 3 AS signed)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(`o`.`OrderID` % 3 AS signed) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(`o`.`OrderID` % 3 AS signed)"); +WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(`o`.`OrderID` % 3 AS signed) +""", + // + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE (`o`.`CustomerID` = 'ALFKI') AND CAST(`o`.`OrderID` % 3 AS signed) +"""); } public override async Task Convert_ToByte(bool async) { await base.Convert_ToByte(async); - AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS unsigned) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS unsigned) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS unsigned) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS unsigned) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS unsigned) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS unsigned) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS unsigned) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS unsigned) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS unsigned) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS unsigned) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS unsigned) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS unsigned) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS unsigned) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS unsigned) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS unsigned) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS unsigned) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS unsigned) >= 0) +""", + // + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS unsigned) >= 0)"); +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS unsigned) >= 0) +"""); } public override async Task Convert_ToDecimal(bool async) { await base.Convert_ToDecimal(async); - AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS decimal(65,30)) >= 0.0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS decimal(65,30)) >= 0.0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS decimal(65,30)) >= 0.0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS decimal(65,30)) >= 0.0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS decimal(65,30)) >= 0.0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS decimal(65,30)) >= 0.0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS decimal(65,30)) >= 0.0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS decimal(65,30)) >= 0.0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS decimal(65,30)) >= 0.0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS decimal(65,30)) >= 0.0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS decimal(65,30)) >= 0.0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS decimal(65,30)) >= 0.0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS decimal(65,30)) >= 0.0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS decimal(65,30)) >= 0.0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS decimal(65,30)) >= 0.0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS decimal(65,30)) >= 0.0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS decimal(65,30)) >= 0.0)"); +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS decimal(65,30)) >= 0.0) +""", + // + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS decimal(65,30)) >= 0.0) +"""); } public override async Task Convert_ToDouble(bool async) @@ -1627,6 +1696,10 @@ public override async Task Convert_ToDouble(bool async) // $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` +WHERE (`o`.`CustomerID` = 'ALFKI') AND ({MySqlTestHelpers.CastAsDouble("CAST(`o`.`OrderID` % 1 AS char)")} >= 0.0)", + // + $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` WHERE (`o`.`CustomerID` = 'ALFKI') AND ({MySqlTestHelpers.CastAsDouble("CAST(`o`.`OrderID` % 1 AS char)")} >= 0.0)"); } @@ -1634,172 +1707,270 @@ public override async Task Convert_ToInt16(bool async) { await base.Convert_ToInt16(async); - AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS signed) >= 0) +""", + // + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS signed) >= 0)"); +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS signed) >= 0) +"""); } public override async Task Convert_ToInt32(bool async) { await base.Convert_ToInt32(async); - AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", + // + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS signed) >= 0)"); +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS signed) >= 0) +"""); } public override async Task Convert_ToInt64(bool async) { await base.Convert_ToInt64(async); - AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0)", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS signed) >= 0) +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS signed) >= 0) +""", + // + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS signed) >= 0)"); +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS char) AS signed) >= 0) +"""); } public override async Task Convert_ToString(bool async) { await base.Convert_ToString(async); - AssertSql( - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS char) <> '10')", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS char) <> '10') +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS char) <> '10')", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS unsigned) AS char) <> '10') +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS char) <> '10')", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS decimal(65,30)) AS char) <> '10') +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS char) <> '10')", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS char) <> '10') +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST({MySqlTestHelpers.CastAsDouble("`o`.`OrderID` % 1")} AS char) <> '10')", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS double) AS char) <> '10') +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS char) <> '10')", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS char) <> '10') +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS char) <> '10')", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS char) <> '10') +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS char) <> '10')", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(CAST(`o`.`OrderID` % 1 AS signed) AS char) <> '10') +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS char) <> '10') +""", + // + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS char) <> '10')", +WHERE (`o`.`CustomerID` = 'ALFKI') AND (CAST(`o`.`OrderID` % 1 AS char) <> '10') +""", // - $@"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + """ +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`CustomerID` = 'ALFKI') AND ((CAST(`o`.`OrderDate` AS char) LIKE '%1997%') OR (CAST(`o`.`OrderDate` AS char) LIKE '%1998%'))"); +WHERE (`o`.`CustomerID` = 'ALFKI') AND ((CAST(`o`.`OrderDate` AS char) LIKE '%1997%') OR (CAST(`o`.`OrderDate` AS char) LIKE '%1998%')) +"""); } public override async Task String_StartsWith_Parameter(bool async) @@ -2175,11 +2346,11 @@ public override async Task Where_mathf_log_new_base(bool async) { await base.Where_mathf_log_new_base(async); - AssertSql( + AssertSql( """ SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` FROM `Order Details` AS `o` -WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7, `o`.`Discount`) < 0) +WHERE ((`o`.`OrderID` = 11077) AND (`o`.`Discount` > 0)) AND (LOG(7, `o`.`Discount`) < -1) """); } @@ -2403,9 +2574,196 @@ public override async Task Where_DateOnly_FromDateTime(bool async) """); } + public override async Task String_StartsWith_with_StringComparison_Ordinal(bool async) + { + await base.String_StartsWith_with_StringComparison_Ordinal(async); + + AssertSql(); + } + + public override async Task String_StartsWith_with_StringComparison_OrdinalIgnoreCase(bool async) + { + await base.String_StartsWith_with_StringComparison_OrdinalIgnoreCase(async); + + AssertSql(); + } + + public override async Task String_EndsWith_with_StringComparison_Ordinal(bool async) + { + await base.String_EndsWith_with_StringComparison_Ordinal(async); + + AssertSql(); + } + + public override async Task String_EndsWith_with_StringComparison_OrdinalIgnoreCase(bool async) + { + await base.String_EndsWith_with_StringComparison_OrdinalIgnoreCase(async); + + AssertSql(); + } + + public override async Task String_Contains_with_StringComparison_Ordinal(bool async) + { + await base.String_Contains_with_StringComparison_Ordinal(async); + + AssertSql(); + } + + public override async Task String_Contains_with_StringComparison_OrdinalIgnoreCase(bool async) + { + await base.String_Contains_with_StringComparison_OrdinalIgnoreCase(async); + + AssertSql(); + } + + public override async Task String_StartsWith_with_StringComparison_unsupported(bool async) + { + await base.String_StartsWith_with_StringComparison_unsupported(async); + + AssertSql(); + } + + public override async Task String_EndsWith_with_StringComparison_unsupported(bool async) + { + await base.String_EndsWith_with_StringComparison_unsupported(async); + + AssertSql(); + } + + public override async Task String_Contains_in_projection(bool async) + { + await base.String_Contains_in_projection(async); + + AssertSql( +""" +SELECT `c`.`CustomerID` AS `Id`, `c`.`ContactName` IS NOT NULL AND ((LOCATE(`c`.`ContactName`, `c`.`CompanyName`) > 0) OR (`c`.`ContactName` LIKE '')) AS `Value` +FROM `Customers` AS `c` +"""); + } + + public override async Task String_Contains_negated_in_predicate(bool async) + { + await base.String_Contains_negated_in_predicate(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`ContactName` IS NULL OR ((LOCATE(`c`.`ContactName`, `c`.`CompanyName`) <= 0) AND `c`.`ContactName` NOT LIKE '') +"""); + } + + public override async Task String_Contains_negated_in_projection(bool async) + { + await base.String_Contains_negated_in_projection(async); + + AssertSql( +""" +SELECT `c`.`CustomerID` AS `Id`, `c`.`ContactName` IS NULL OR ((LOCATE(`c`.`ContactName`, `c`.`CompanyName`) <= 0) AND `c`.`ContactName` NOT LIKE '') AS `Value` +FROM `Customers` AS `c` +"""); + } + + public override async Task String_Contains_with_StringComparison_unsupported(bool async) + { + await base.String_Contains_with_StringComparison_unsupported(async); + + AssertSql(); + } + + public override async Task String_Join_non_aggregate(bool async) + { + await base.String_Join_non_aggregate(async); + + AssertSql( +""" +@__foo_0='foo' (Size = 4000) + +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE CONCAT_WS('|', `c`.`CompanyName`, @__foo_0, '', 'bar') = 'Around the Horn|foo||bar' +"""); + } + + public override async Task Where_math_max_nested(bool async) + { + await base.Where_math_max_nested(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` +FROM `Order Details` AS `o` +WHERE (`o`.`OrderID` = 11077) AND (GREATEST(`o`.`OrderID`, `o`.`ProductID`, 1) = `o`.`OrderID`) +"""); + } + + public override async Task Where_math_max_nested_twice(bool async) + { + await base.Where_math_max_nested_twice(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` +FROM `Order Details` AS `o` +WHERE (`o`.`OrderID` = 11077) AND (GREATEST(1, `o`.`OrderID`, 2, `o`.`ProductID`) = `o`.`OrderID`) +"""); + } + + public override async Task Where_math_min_nested(bool async) + { + await base.Where_math_min_nested(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` +FROM `Order Details` AS `o` +WHERE (`o`.`OrderID` = 11077) AND (LEAST(`o`.`OrderID`, `o`.`ProductID`, 99999) = `o`.`ProductID`) +"""); + } + + public override async Task Where_math_min_nested_twice(bool async) + { + await base.Where_math_min_nested_twice(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` +FROM `Order Details` AS `o` +WHERE (`o`.`OrderID` = 11077) AND (LEAST(99999, `o`.`OrderID`, 99998, `o`.`ProductID`) = `o`.`ProductID`) +"""); + } + + public override async Task Select_ToString_IndexOf(bool async) + { + await base.Select_ToString_IndexOf(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE (LOCATE('123', CAST(`o`.`OrderID` AS char)) - 1) = -1 +"""); + } + + public override async Task Select_IndexOf_ToString(bool async) + { + await base.Select_IndexOf_ToString(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE (LOCATE(CAST(`o`.`OrderID` AS char), '123') - 1) = -1 +"""); + } + public override Task Datetime_subtraction_TotalDays(bool async) => AssertTranslationFailed(() => base.Datetime_subtraction_TotalDays(async)); + [ConditionalFact] + public virtual void Check_all_tests_overridden() + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); + private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindGroupByQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindGroupByQueryMySqlTest.cs index e53d3002c..b44d9f100 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindGroupByQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindGroupByQueryMySqlTest.cs @@ -1,7 +1,9 @@ using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestUtilities; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.Infrastructure; +using Pomelo.EntityFrameworkCore.MySql.Tests; using Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes; using Xunit; using Xunit.Abstractions; @@ -20,9 +22,6 @@ public NorthwindGroupByQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - public override async Task AsEnumerable_in_subquery_for_GroupBy(bool async) { await base.AsEnumerable_in_subquery_for_GroupBy(async); @@ -140,26 +139,3661 @@ public override async Task GroupBy_group_Distinct_Select_Distinct_aggregate(bool GROUP BY `o`.`CustomerID`"); } - [SupportedServerVersionCondition(nameof(ServerVersionSupport.OuterReferenceInMultiLevelSubquery))] - public override Task GroupBy_Count_in_projection(bool async) + public override async Task GroupBy_Property_Select_Average(bool async) { - return base.GroupBy_Count_in_projection(async); + await base.GroupBy_Property_Select_Average(async); + + AssertSql( +""" +SELECT AVG(CAST(`o`.`OrderID` AS double)) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); } - [SupportedServerVersionCondition("8.0.22-mysql", "0.0.0-mariadb")] - public override Task GroupBy_group_Where_Select_Distinct_aggregate(bool async) + public override async Task GroupBy_Property_Select_Average_with_group_enumerable_projected(bool async) { - // See https://github.com/mysql-net/MySqlConnector/issues/898. - return base.GroupBy_group_Where_Select_Distinct_aggregate(async); + await base.GroupBy_Property_Select_Average_with_group_enumerable_projected(async); + + AssertSql(); } - [SupportedServerVersionCondition("8.0.0-mysql", "0.0.0-mariadb")] // Is an issue issue in MySQL 5.7.34, but not in 8.0.25. - public override Task GroupBy_constant_with_where_on_grouping_with_aggregate_operators(bool async) + public override async Task GroupBy_Property_Select_Count(bool async) { - // See https://github.com/mysql-net/MySqlConnector/issues/980. - return base.GroupBy_constant_with_where_on_grouping_with_aggregate_operators(async); + await base.GroupBy_Property_Select_Count(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_LongCount(bool async) + { + await base.GroupBy_Property_Select_LongCount(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Count_with_nulls(bool async) + { + await base.GroupBy_Property_Select_Count_with_nulls(async); + + AssertSql( +""" +SELECT `c`.`City`, COUNT(*) AS `Faxes` +FROM `Customers` AS `c` +GROUP BY `c`.`City` +"""); + } + + public override async Task GroupBy_Property_Select_LongCount_with_nulls(bool async) + { + await base.GroupBy_Property_Select_LongCount_with_nulls(async); + + AssertSql( +""" +SELECT `c`.`City`, COUNT(*) AS `Faxes` +FROM `Customers` AS `c` +GROUP BY `c`.`City` +"""); + } + + public override async Task GroupBy_Property_Select_Max(bool async) + { + await base.GroupBy_Property_Select_Max(async); + + AssertSql( +""" +SELECT MAX(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Min(bool async) + { + await base.GroupBy_Property_Select_Min(async); + + AssertSql( +""" +SELECT MIN(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Sum(bool async) + { + await base.GroupBy_Property_Select_Sum(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Sum_Min_Max_Avg(bool async) + { + await base.GroupBy_Property_Select_Sum_Min_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Key_Average(bool async) + { + await base.GroupBy_Property_Select_Key_Average(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, AVG(CAST(`o`.`OrderID` AS double)) AS `Average` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Key_Count(bool async) + { + await base.GroupBy_Property_Select_Key_Count(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `Count` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Key_LongCount(bool async) + { + await base.GroupBy_Property_Select_Key_LongCount(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `LongCount` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Key_Max(bool async) + { + await base.GroupBy_Property_Select_Key_Max(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, MAX(`o`.`OrderID`) AS `Max` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Key_Min(bool async) + { + await base.GroupBy_Property_Select_Key_Min(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, MIN(`o`.`OrderID`) AS `Min` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Key_Sum(bool async) + { + await base.GroupBy_Property_Select_Key_Sum(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Key_Sum_Min_Max_Avg(bool async) + { + await base.GroupBy_Property_Select_Key_Sum_Min_Max_Avg(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Sum_Min_Key_Max_Avg(bool async) + { + await base.GroupBy_Property_Select_Sum_Min_Key_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, `o`.`CustomerID` AS `Key`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_key_multiple_times_and_aggregate(bool async) + { + await base.GroupBy_Property_Select_key_multiple_times_and_aggregate(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key1`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Key_with_constant(bool async) + { + await base.GroupBy_Property_Select_Key_with_constant(async); + + AssertSql( +""" +SELECT `o0`.`Name`, `o0`.`CustomerID` AS `Value`, COUNT(*) AS `Count` +FROM ( + SELECT `o`.`CustomerID`, 'CustomerID' AS `Name` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Name`, `o0`.`CustomerID` +"""); + } + + public override async Task GroupBy_aggregate_projecting_conditional_expression(bool async) + { + await base.GroupBy_aggregate_projecting_conditional_expression(async); + + AssertSql( +""" +SELECT `o`.`OrderDate` AS `Key`, CASE + WHEN COUNT(*) = 0 THEN 1 + ELSE COALESCE(SUM(CASE + WHEN (`o`.`OrderID` % 2) = 0 THEN 1 + ELSE 0 + END), 0) / COUNT(*) +END AS `SomeValue` +FROM `Orders` AS `o` +GROUP BY `o`.`OrderDate` +"""); + } + + public override async Task GroupBy_aggregate_projecting_conditional_expression_based_on_group_key(bool async) + { + await base.GroupBy_aggregate_projecting_conditional_expression_based_on_group_key(async); + + AssertSql( +""" +SELECT CASE + WHEN `o`.`OrderDate` IS NULL THEN 'is null' + ELSE 'is not null' +END AS `Key`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`OrderDate` +"""); + } + + public override async Task GroupBy_with_group_key_access_thru_navigation(bool async) + { + await base.GroupBy_with_group_key_access_thru_navigation(async); + + AssertSql( +""" +SELECT `o0`.`CustomerID` AS `Key`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Aggregate` +FROM `Order Details` AS `o` +INNER JOIN `Orders` AS `o0` ON `o`.`OrderID` = `o0`.`OrderID` +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task GroupBy_with_group_key_access_thru_nested_navigation(bool async) + { + await base.GroupBy_with_group_key_access_thru_nested_navigation(async); + + AssertSql( +""" +SELECT `c`.`Country` AS `Key`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Aggregate` +FROM `Order Details` AS `o` +INNER JOIN `Orders` AS `o0` ON `o`.`OrderID` = `o0`.`OrderID` +LEFT JOIN `Customers` AS `c` ON `o0`.`CustomerID` = `c`.`CustomerID` +GROUP BY `c`.`Country` +"""); + } + + public override async Task GroupBy_with_grouping_key_using_Like(bool async) + { + await base.GroupBy_with_grouping_key_using_Like(async); + + AssertSql( +""" +SELECT `o0`.`Key`, COUNT(*) AS `Count` +FROM ( + SELECT (`o`.`CustomerID` LIKE 'A%') AND `o`.`CustomerID` IS NOT NULL AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_with_grouping_key_DateTime_Day(bool async) + { + await base.GroupBy_with_grouping_key_DateTime_Day(async); + + AssertSql( +""" +SELECT `o0`.`Key`, COUNT(*) AS `Count` +FROM ( + SELECT EXTRACT(day FROM `o`.`OrderDate`) AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_with_cast_inside_grouping_aggregate(bool async) + { + await base.GroupBy_with_cast_inside_grouping_aggregate(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `Count`, COALESCE(SUM(CAST(`o`.`OrderID` AS signed)), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task Group_by_with_arithmetic_operation_inside_aggregate(bool async) + { + await base.Group_by_with_arithmetic_operation_inside_aggregate(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COALESCE(SUM(`o`.`OrderID` + CHAR_LENGTH(`o`.`CustomerID`)), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task Group_by_with_projection_into_DTO(bool async) + { + await base.Group_by_with_projection_into_DTO(async); + + AssertSql( +""" +SELECT CAST(`o`.`OrderID` AS signed) AS `Id`, COUNT(*) AS `Count` +FROM `Orders` AS `o` +GROUP BY `o`.`OrderID` +"""); + } + + public override async Task Where_select_function_groupby_followed_by_another_select_with_aggregates(bool async) + { + await base.Where_select_function_groupby_followed_by_another_select_with_aggregates(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COALESCE(SUM(CASE + WHEN (2020 - EXTRACT(year FROM `o`.`OrderDate`)) <= 30 THEN `o`.`OrderID` + ELSE 0 +END), 0) AS `Sum1`, COALESCE(SUM(CASE + WHEN ((2020 - EXTRACT(year FROM `o`.`OrderDate`)) > 30) AND ((2020 - EXTRACT(year FROM `o`.`OrderDate`)) <= 60) THEN `o`.`OrderID` + ELSE 0 +END), 0) AS `Sum2` +FROM `Orders` AS `o` +WHERE `o`.`CustomerID` LIKE 'A%' +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task Group_by_column_project_constant(bool async) + { + await base.Group_by_column_project_constant(async); + + AssertSql( +""" +SELECT 42 +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +ORDER BY `o`.`CustomerID` +"""); + } + + public override async Task Key_plus_key_in_projection(bool async) + { + await base.Key_plus_key_in_projection(async); + + AssertSql( +""" +SELECT `o`.`OrderID` + `o`.`OrderID` AS `Value`, AVG(CAST(`o`.`OrderID` AS double)) AS `Average` +FROM `Orders` AS `o` +LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +GROUP BY `o`.`OrderID` +"""); } + public override async Task GroupBy_with_aggregate_through_navigation_property(bool async) + { + await base.GroupBy_with_aggregate_through_navigation_property(async); + + AssertSql( +""" +SELECT ( + SELECT MAX(`c`.`Region`) + FROM `Orders` AS `o0` + LEFT JOIN `Customers` AS `c` ON `o0`.`CustomerID` = `c`.`CustomerID` + WHERE (`o`.`EmployeeID` = `o0`.`EmployeeID`) OR (`o`.`EmployeeID` IS NULL AND (`o0`.`EmployeeID` IS NULL))) AS `max` +FROM `Orders` AS `o` +GROUP BY `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_with_aggregate_containing_complex_where(bool async) + { + await base.GroupBy_with_aggregate_containing_complex_where(async); + + AssertSql( +""" +SELECT `o`.`EmployeeID` AS `Key`, ( + SELECT MAX(`o0`.`OrderID`) + FROM `Orders` AS `o0` + WHERE (CAST(`o0`.`EmployeeID` AS signed) = CAST(MAX(`o`.`OrderID`) * 6 AS signed)) OR (`o0`.`EmployeeID` IS NULL AND (MAX(`o`.`OrderID`) IS NULL))) AS `Max` +FROM `Orders` AS `o` +GROUP BY `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_anonymous_Select_Average(bool async) + { + await base.GroupBy_anonymous_Select_Average(async); + + AssertSql( +""" +SELECT AVG(CAST(`o`.`OrderID` AS double)) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_anonymous_Select_Count(bool async) + { + await base.GroupBy_anonymous_Select_Count(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_anonymous_Select_LongCount(bool async) + { + await base.GroupBy_anonymous_Select_LongCount(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_anonymous_Select_Max(bool async) + { + await base.GroupBy_anonymous_Select_Max(async); + + AssertSql( +""" +SELECT MAX(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_anonymous_Select_Min(bool async) + { + await base.GroupBy_anonymous_Select_Min(async); + + AssertSql( +""" +SELECT MIN(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_anonymous_Select_Sum(bool async) + { + await base.GroupBy_anonymous_Select_Sum(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_anonymous_Select_Sum_Min_Max_Avg(bool async) + { + await base.GroupBy_anonymous_Select_Sum_Min_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_anonymous_with_alias_Select_Key_Sum(bool async) + { + await base.GroupBy_anonymous_with_alias_Select_Key_Sum(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Composite_Select_Average(bool async) + { + await base.GroupBy_Composite_Select_Average(async); + + AssertSql( +""" +SELECT AVG(CAST(`o`.`OrderID` AS double)) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Count(bool async) + { + await base.GroupBy_Composite_Select_Count(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_LongCount(bool async) + { + await base.GroupBy_Composite_Select_LongCount(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Max(bool async) + { + await base.GroupBy_Composite_Select_Max(async); + + AssertSql( +""" +SELECT MAX(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Min(bool async) + { + await base.GroupBy_Composite_Select_Min(async); + + AssertSql( +""" +SELECT MIN(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Sum(bool async) + { + await base.GroupBy_Composite_Select_Sum(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Sum_Min_Max_Avg(bool async) + { + await base.GroupBy_Composite_Select_Sum_Min_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Key_Average(bool async) + { + await base.GroupBy_Composite_Select_Key_Average(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, `o`.`EmployeeID`, AVG(CAST(`o`.`OrderID` AS double)) AS `Average` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Key_Count(bool async) + { + await base.GroupBy_Composite_Select_Key_Count(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, `o`.`EmployeeID`, COUNT(*) AS `Count` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Key_LongCount(bool async) + { + await base.GroupBy_Composite_Select_Key_LongCount(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, `o`.`EmployeeID`, COUNT(*) AS `LongCount` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Key_Max(bool async) + { + await base.GroupBy_Composite_Select_Key_Max(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, `o`.`EmployeeID`, MAX(`o`.`OrderID`) AS `Max` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Key_Min(bool async) + { + await base.GroupBy_Composite_Select_Key_Min(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, `o`.`EmployeeID`, MIN(`o`.`OrderID`) AS `Min` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Key_Sum(bool async) + { + await base.GroupBy_Composite_Select_Key_Sum(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, `o`.`EmployeeID`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Key_Sum_Min_Max_Avg(bool async) + { + await base.GroupBy_Composite_Select_Key_Sum_Min_Max_Avg(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, `o`.`EmployeeID`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Sum_Min_Key_Max_Avg(bool async) + { + await base.GroupBy_Composite_Select_Sum_Min_Key_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, `o`.`CustomerID`, `o`.`EmployeeID`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Sum_Min_Key_flattened_Max_Avg(bool async) + { + await base.GroupBy_Composite_Select_Sum_Min_Key_flattened_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, `o`.`CustomerID`, `o`.`EmployeeID`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Dto_as_key_Select_Sum(bool async) + { + await base.GroupBy_Dto_as_key_Select_Sum(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, `o`.`CustomerID`, `o`.`EmployeeID` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Dto_as_element_selector_Select_Sum(bool async) + { + await base.GroupBy_Dto_as_element_selector_Select_Sum(async); + + AssertSql( +""" +SELECT COALESCE(SUM(CAST(`o`.`EmployeeID` AS signed)), 0) AS `Sum`, `o`.`CustomerID` AS `Key` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Composite_Select_Dto_Sum_Min_Key_flattened_Max_Avg(bool async) + { + await base.GroupBy_Composite_Select_Dto_Sum_Min_Key_flattened_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, `o`.`CustomerID` AS `CustomerId`, `o`.`EmployeeID` AS `EmployeeId`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Composite_Select_Sum_Min_part_Key_flattened_Max_Avg(bool async) + { + await base.GroupBy_Composite_Select_Sum_Min_part_Key_flattened_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, `o`.`CustomerID`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID`, `o`.`EmployeeID` +"""); + } + + public override async Task GroupBy_Constant_Select_Sum_Min_Key_Max_Avg(bool async) + { + await base.GroupBy_Constant_Select_Sum_Min_Key_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum`, MIN(`o0`.`OrderID`) AS `Min`, `o0`.`Key`, MAX(`o0`.`OrderID`) AS `Max`, AVG(CAST(`o0`.`OrderID` AS double)) AS `Avg` +FROM ( + SELECT `o`.`OrderID`, 2 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_Constant_with_element_selector_Select_Sum(bool async) + { + await base.GroupBy_Constant_with_element_selector_Select_Sum(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum` +FROM ( + SELECT `o`.`OrderID`, 2 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_Constant_with_element_selector_Select_Sum2(bool async) + { + await base.GroupBy_Constant_with_element_selector_Select_Sum2(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum` +FROM ( + SELECT `o`.`OrderID`, 2 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_Constant_with_element_selector_Select_Sum3(bool async) + { + await base.GroupBy_Constant_with_element_selector_Select_Sum3(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum` +FROM ( + SELECT `o`.`OrderID`, 2 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_after_predicate_Constant_Select_Sum_Min_Key_Max_Avg(bool async) + { + await base.GroupBy_after_predicate_Constant_Select_Sum_Min_Key_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum`, MIN(`o0`.`OrderID`) AS `Min`, `o0`.`Key` AS `Random`, MAX(`o0`.`OrderID`) AS `Max`, AVG(CAST(`o0`.`OrderID` AS double)) AS `Avg` +FROM ( + SELECT `o`.`OrderID`, 2 AS `Key` + FROM `Orders` AS `o` + WHERE `o`.`OrderID` > 10500 +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_Constant_with_element_selector_Select_Sum_Min_Key_Max_Avg(bool async) + { + await base.GroupBy_Constant_with_element_selector_Select_Sum_Min_Key_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum`, `o0`.`Key` +FROM ( + SELECT `o`.`OrderID`, 2 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_param_Select_Sum_Min_Key_Max_Avg(bool async) + { + await base.GroupBy_param_Select_Sum_Min_Key_Max_Avg(async); + + AssertSql( +""" +@__a_0='2' + +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum`, MIN(`o0`.`OrderID`) AS `Min`, `o0`.`Key`, MAX(`o0`.`OrderID`) AS `Max`, AVG(CAST(`o0`.`OrderID` AS double)) AS `Avg` +FROM ( + SELECT `o`.`OrderID`, @__a_0 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_param_with_element_selector_Select_Sum(bool async) + { + await base.GroupBy_param_with_element_selector_Select_Sum(async); + + AssertSql( +""" +@__a_0='2' + +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum` +FROM ( + SELECT `o`.`OrderID`, @__a_0 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_param_with_element_selector_Select_Sum2(bool async) + { + await base.GroupBy_param_with_element_selector_Select_Sum2(async); + + AssertSql( +""" +@__a_0='2' + +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum` +FROM ( + SELECT `o`.`OrderID`, @__a_0 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_param_with_element_selector_Select_Sum3(bool async) + { + await base.GroupBy_param_with_element_selector_Select_Sum3(async); + + AssertSql( +""" +@__a_0='2' + +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum` +FROM ( + SELECT `o`.`OrderID`, @__a_0 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_param_with_element_selector_Select_Sum_Min_Key_Max_Avg(bool async) + { + await base.GroupBy_param_with_element_selector_Select_Sum_Min_Key_Max_Avg(async); + + AssertSql( +""" +@__a_0='2' + +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum`, `o0`.`Key` +FROM ( + SELECT `o`.`OrderID`, @__a_0 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_anonymous_key_type_mismatch_with_aggregate(bool async) + { + await base.GroupBy_anonymous_key_type_mismatch_with_aggregate(async); + + AssertSql( +""" +SELECT COUNT(*) AS `I0`, `o0`.`I0` AS `I1` +FROM ( + SELECT EXTRACT(year FROM `o`.`OrderDate`) AS `I0` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`I0` +ORDER BY `o0`.`I0` +"""); + } + + public override async Task GroupBy_based_on_renamed_property_simple(bool async) + { + await base.GroupBy_based_on_renamed_property_simple(async); + + AssertSql( +""" +SELECT `c`.`City` AS `Renamed`, COUNT(*) AS `Count` +FROM `Customers` AS `c` +GROUP BY `c`.`City` +"""); + } + + public override async Task GroupBy_based_on_renamed_property_complex(bool async) + { + await base.GroupBy_based_on_renamed_property_complex(async); + + AssertSql( +""" +SELECT `c0`.`Renamed` AS `Key`, COUNT(*) AS `Count` +FROM ( + SELECT DISTINCT `c`.`City` AS `Renamed`, `c`.`CustomerID` + FROM `Customers` AS `c` +) AS `c0` +GROUP BY `c0`.`Renamed` +"""); + } + + public override async Task Join_groupby_anonymous_orderby_anonymous_projection(bool async) + { + await base.Join_groupby_anonymous_orderby_anonymous_projection(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `o`.`OrderDate` +FROM `Customers` AS `c` +INNER JOIN `Orders` AS `o` ON `c`.`CustomerID` = `o`.`CustomerID` +GROUP BY `c`.`CustomerID`, `o`.`OrderDate` +ORDER BY `o`.`OrderDate` +"""); + } + + public override async Task Odata_groupby_empty_key(bool async) + { + await base.Odata_groupby_empty_key(async); + + AssertSql( +""" +SELECT 'TotalAmount' AS `Name`, COALESCE(SUM(CAST(`o0`.`OrderID` AS decimal(65,30))), 0.0) AS `Value` +FROM ( + SELECT `o`.`OrderID`, 1 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_Property_scalar_element_selector_Average(bool async) + { + await base.GroupBy_Property_scalar_element_selector_Average(async); + + AssertSql( +""" +SELECT AVG(CAST(`o`.`OrderID` AS double)) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_scalar_element_selector_Count(bool async) + { + await base.GroupBy_Property_scalar_element_selector_Count(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_scalar_element_selector_LongCount(bool async) + { + await base.GroupBy_Property_scalar_element_selector_LongCount(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_scalar_element_selector_Max(bool async) + { + await base.GroupBy_Property_scalar_element_selector_Max(async); + + AssertSql( +""" +SELECT MAX(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_scalar_element_selector_Min(bool async) + { + await base.GroupBy_Property_scalar_element_selector_Min(async); + + AssertSql( +""" +SELECT MIN(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_scalar_element_selector_Sum(bool async) + { + await base.GroupBy_Property_scalar_element_selector_Sum(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_scalar_element_selector_Sum_Min_Max_Avg(bool async) + { + await base.GroupBy_Property_scalar_element_selector_Sum_Min_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_anonymous_element_selector_Average(bool async) + { + await base.GroupBy_Property_anonymous_element_selector_Average(async); + + AssertSql( +""" +SELECT AVG(CAST(`o`.`OrderID` AS double)) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_anonymous_element_selector_Count(bool async) + { + await base.GroupBy_Property_anonymous_element_selector_Count(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_anonymous_element_selector_LongCount(bool async) + { + await base.GroupBy_Property_anonymous_element_selector_LongCount(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_anonymous_element_selector_Max(bool async) + { + await base.GroupBy_Property_anonymous_element_selector_Max(async); + + AssertSql( +""" +SELECT MAX(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_anonymous_element_selector_Min(bool async) + { + await base.GroupBy_Property_anonymous_element_selector_Min(async); + + AssertSql( +""" +SELECT MIN(`o`.`OrderID`) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_anonymous_element_selector_Sum(bool async) + { + await base.GroupBy_Property_anonymous_element_selector_Sum(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_anonymous_element_selector_Sum_Min_Max_Avg(bool async) + { + await base.GroupBy_Property_anonymous_element_selector_Sum_Min_Max_Avg(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`EmployeeID`) AS `Min`, MAX(`o`.`EmployeeID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_element_selector_complex_aggregate(bool async) + { + await base.GroupBy_element_selector_complex_aggregate(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID` + 1), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_element_selector_complex_aggregate2(bool async) + { + await base.GroupBy_element_selector_complex_aggregate2(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID` + 1), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_element_selector_complex_aggregate3(bool async) + { + await base.GroupBy_element_selector_complex_aggregate3(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID` + 1), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_element_selector_complex_aggregate4(bool async) + { + await base.GroupBy_element_selector_complex_aggregate4(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID` + 1), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task Element_selector_with_case_block_repeated_inside_another_case_block_in_projection(bool async) + { + await base.Element_selector_with_case_block_repeated_inside_another_case_block_in_projection(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, COALESCE(SUM(CASE + WHEN `o`.`CustomerID` = 'ALFKI' THEN CASE + WHEN `o`.`OrderID` > 1000 THEN `o`.`OrderID` + ELSE -`o`.`OrderID` + END + ELSE -CASE + WHEN `o`.`OrderID` > 1000 THEN `o`.`OrderID` + ELSE -`o`.`OrderID` + END +END), 0) AS `Aggregate` +FROM `Orders` AS `o` +GROUP BY `o`.`OrderID` +"""); + } + + public override async Task GroupBy_conditional_properties(bool async) + { + await base.GroupBy_conditional_properties(async); + + AssertSql( +""" +SELECT `o0`.`OrderMonth`, `o0`.`CustomerID` AS `Customer`, COUNT(*) AS `Count` +FROM ( + SELECT `o`.`CustomerID`, NULL AS `OrderMonth` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`OrderMonth`, `o0`.`CustomerID` +"""); + } + + public override async Task GroupBy_empty_key_Aggregate(bool async) + { + await base.GroupBy_empty_key_Aggregate(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) +FROM ( + SELECT `o`.`OrderID`, 1 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_empty_key_Aggregate_Key(bool async) + { + await base.GroupBy_empty_key_Aggregate_Key(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) AS `Sum` +FROM ( + SELECT `o`.`OrderID`, 1 AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task OrderBy_GroupBy_Aggregate(bool async) + { + await base.OrderBy_GroupBy_Aggregate(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task OrderBy_Skip_GroupBy_Aggregate(bool async) + { + await base.OrderBy_Skip_GroupBy_Aggregate(async); + + AssertSql( +""" +@__p_0='80' + +SELECT AVG(CAST(`o0`.`OrderID` AS double)) +FROM ( + SELECT `o`.`OrderID`, `o`.`CustomerID` + FROM `Orders` AS `o` + ORDER BY `o`.`OrderID` + LIMIT 18446744073709551610 OFFSET @__p_0 +) AS `o0` +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task OrderBy_Take_GroupBy_Aggregate(bool async) + { + await base.OrderBy_Take_GroupBy_Aggregate(async); + + AssertSql( +""" +@__p_0='500' + +SELECT MIN(`o0`.`OrderID`) +FROM ( + SELECT `o`.`OrderID`, `o`.`CustomerID` + FROM `Orders` AS `o` + ORDER BY `o`.`OrderID` + LIMIT @__p_0 +) AS `o0` +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task OrderBy_Skip_Take_GroupBy_Aggregate(bool async) + { + await base.OrderBy_Skip_Take_GroupBy_Aggregate(async); + + AssertSql( +""" +@__p_1='500' +@__p_0='80' + +SELECT MAX(`o0`.`OrderID`) +FROM ( + SELECT `o`.`OrderID`, `o`.`CustomerID` + FROM `Orders` AS `o` + ORDER BY `o`.`OrderID` + LIMIT @__p_1 OFFSET @__p_0 +) AS `o0` +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task Distinct_GroupBy_Aggregate(bool async) + { + await base.Distinct_GroupBy_Aggregate(async); + + AssertSql( +""" +SELECT `o0`.`CustomerID` AS `Key`, COUNT(*) AS `c` +FROM ( + SELECT DISTINCT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task Anonymous_projection_Distinct_GroupBy_Aggregate(bool async) + { + await base.Anonymous_projection_Distinct_GroupBy_Aggregate(async); + + AssertSql( +""" +SELECT `o0`.`EmployeeID` AS `Key`, COUNT(*) AS `c` +FROM ( + SELECT DISTINCT `o`.`OrderID`, `o`.`EmployeeID` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`EmployeeID` +"""); + } + + public override async Task SelectMany_GroupBy_Aggregate(bool async) + { + await base.SelectMany_GroupBy_Aggregate(async); + + AssertSql( +""" +SELECT `o`.`EmployeeID` AS `Key`, COUNT(*) AS `c` +FROM `Customers` AS `c` +INNER JOIN `Orders` AS `o` ON `c`.`CustomerID` = `o`.`CustomerID` +GROUP BY `o`.`EmployeeID` +"""); + } + + public override async Task Join_GroupBy_Aggregate(bool async) + { + await base.Join_GroupBy_Aggregate(async); + + AssertSql( +""" +SELECT `c`.`CustomerID` AS `Key`, AVG(CAST(`o`.`OrderID` AS double)) AS `Count` +FROM `Orders` AS `o` +INNER JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +GROUP BY `c`.`CustomerID` +"""); + } + + public override async Task GroupBy_required_navigation_member_Aggregate(bool async) + { + await base.GroupBy_required_navigation_member_Aggregate(async); + + AssertSql( +""" +SELECT `o0`.`CustomerID` AS `CustomerId`, COUNT(*) AS `Count` +FROM `Order Details` AS `o` +INNER JOIN `Orders` AS `o0` ON `o`.`OrderID` = `o0`.`OrderID` +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task Join_complex_GroupBy_Aggregate(bool async) + { + await base.Join_complex_GroupBy_Aggregate(async); + + AssertSql( +""" +@__p_0='100' +@__p_2='50' +@__p_1='10' + +SELECT `c0`.`CustomerID` AS `Key`, AVG(CAST(`o0`.`OrderID` AS double)) AS `Count` +FROM ( + SELECT `o`.`OrderID`, `o`.`CustomerID` + FROM `Orders` AS `o` + WHERE `o`.`OrderID` < 10400 + ORDER BY `o`.`OrderDate` + LIMIT @__p_0 +) AS `o0` +INNER JOIN ( + SELECT `c`.`CustomerID` + FROM `Customers` AS `c` + WHERE `c`.`CustomerID` NOT IN ('DRACD', 'FOLKO') + ORDER BY `c`.`City` + LIMIT @__p_2 OFFSET @__p_1 +) AS `c0` ON `o0`.`CustomerID` = `c0`.`CustomerID` +GROUP BY `c0`.`CustomerID` +"""); + } + + public override async Task GroupJoin_GroupBy_Aggregate(bool async) + { + await base.GroupJoin_GroupBy_Aggregate(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, AVG(CAST(`o`.`OrderID` AS double)) AS `Average` +FROM `Customers` AS `c` +LEFT JOIN `Orders` AS `o` ON `c`.`CustomerID` = `o`.`CustomerID` +WHERE `o`.`OrderID` IS NOT NULL +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupJoin_GroupBy_Aggregate_2(bool async) + { + await base.GroupJoin_GroupBy_Aggregate_2(async); + + AssertSql( +""" +SELECT `c`.`CustomerID` AS `Key`, MAX(`c`.`City`) AS `Max` +FROM `Customers` AS `c` +LEFT JOIN `Orders` AS `o` ON `c`.`CustomerID` = `o`.`CustomerID` +GROUP BY `c`.`CustomerID` +"""); + } + + public override async Task GroupJoin_GroupBy_Aggregate_3(bool async) + { + await base.GroupJoin_GroupBy_Aggregate_3(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, AVG(CAST(`o`.`OrderID` AS double)) AS `Average` +FROM `Orders` AS `o` +LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupJoin_GroupBy_Aggregate_4(bool async) + { + await base.GroupJoin_GroupBy_Aggregate_4(async); + + AssertSql( +""" +SELECT `c`.`CustomerID` AS `Value`, MAX(`c`.`City`) AS `Max` +FROM `Customers` AS `c` +LEFT JOIN `Orders` AS `o` ON `c`.`CustomerID` = `o`.`CustomerID` +GROUP BY `c`.`CustomerID` +"""); + } + + public override async Task GroupJoin_GroupBy_Aggregate_5(bool async) + { + await base.GroupJoin_GroupBy_Aggregate_5(async); + + AssertSql( +""" +SELECT `o`.`OrderID` AS `Value`, AVG(CAST(`o`.`OrderID` AS double)) AS `Average` +FROM `Orders` AS `o` +LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +GROUP BY `o`.`OrderID` +"""); + } + + public override async Task GroupBy_optional_navigation_member_Aggregate(bool async) + { + await base.GroupBy_optional_navigation_member_Aggregate(async); + + AssertSql( +""" +SELECT `c`.`Country`, COUNT(*) AS `Count` +FROM `Orders` AS `o` +LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +GROUP BY `c`.`Country` +"""); + } + + public override async Task GroupJoin_complex_GroupBy_Aggregate(bool async) + { + await base.GroupJoin_complex_GroupBy_Aggregate(async); + + AssertSql( +""" +@__p_1='50' +@__p_0='10' +@__p_2='100' + +SELECT `o0`.`CustomerID` AS `Key`, AVG(CAST(`o0`.`OrderID` AS double)) AS `Count` +FROM ( + SELECT `c`.`CustomerID` + FROM `Customers` AS `c` + WHERE `c`.`CustomerID` NOT IN ('DRACD', 'FOLKO') + ORDER BY `c`.`City` + LIMIT @__p_1 OFFSET @__p_0 +) AS `c0` +INNER JOIN ( + SELECT `o`.`OrderID`, `o`.`CustomerID` + FROM `Orders` AS `o` + WHERE `o`.`OrderID` < 10400 + ORDER BY `o`.`OrderDate` + LIMIT @__p_2 +) AS `o0` ON `c0`.`CustomerID` = `o0`.`CustomerID` +WHERE `o0`.`OrderID` > 10300 +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task Self_join_GroupBy_Aggregate(bool async) + { + await base.Self_join_GroupBy_Aggregate(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, AVG(CAST(`o0`.`OrderID` AS double)) AS `Count` +FROM `Orders` AS `o` +INNER JOIN `Orders` AS `o0` ON `o`.`OrderID` = `o0`.`OrderID` +WHERE `o`.`OrderID` < 10400 +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_multi_navigation_members_Aggregate(bool async) + { + await base.GroupBy_multi_navigation_members_Aggregate(async); + + AssertSql( +""" +SELECT `o0`.`CustomerID`, `p`.`ProductName`, COUNT(*) AS `Count` +FROM `Order Details` AS `o` +INNER JOIN `Orders` AS `o0` ON `o`.`OrderID` = `o0`.`OrderID` +INNER JOIN `Products` AS `p` ON `o`.`ProductID` = `p`.`ProductID` +GROUP BY `o0`.`CustomerID`, `p`.`ProductName` +"""); + } + + public override async Task Union_simple_groupby(bool async) + { + await base.Union_simple_groupby(async); + + AssertSql( +""" +SELECT `u`.`City` AS `Key`, COUNT(*) AS `Total` +FROM ( + SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + FROM `Customers` AS `c` + WHERE `c`.`ContactTitle` = 'Owner' + UNION + SELECT `c0`.`CustomerID`, `c0`.`Address`, `c0`.`City`, `c0`.`CompanyName`, `c0`.`ContactName`, `c0`.`ContactTitle`, `c0`.`Country`, `c0`.`Fax`, `c0`.`Phone`, `c0`.`PostalCode`, `c0`.`Region` + FROM `Customers` AS `c0` + WHERE `c0`.`City` = 'México D.F.' +) AS `u` +GROUP BY `u`.`City` +"""); + } + + public override async Task Select_anonymous_GroupBy_Aggregate(bool async) + { + await base.Select_anonymous_GroupBy_Aggregate(async); + + AssertSql( +""" +SELECT MIN(`o`.`OrderDate`) AS `Min`, MAX(`o`.`OrderDate`) AS `Max`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +WHERE `o`.`OrderID` < 10300 +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_principal_key_property_optimization(bool async) + { + await base.GroupBy_principal_key_property_optimization(async); + + AssertSql( +""" +SELECT `c`.`CustomerID` AS `Key`, COUNT(*) AS `Count` +FROM `Orders` AS `o` +LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +GROUP BY `c`.`CustomerID` +"""); + } + + public override async Task GroupBy_after_anonymous_projection_and_distinct_followed_by_another_anonymous_projection(bool async) + { + await base.GroupBy_after_anonymous_projection_and_distinct_followed_by_another_anonymous_projection(async); + + AssertSql( +""" +SELECT `o0`.`CustomerID` AS `Key`, COUNT(*) AS `Count` +FROM ( + SELECT DISTINCT `o`.`CustomerID`, `o`.`OrderID` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task GroupBy_complex_key_aggregate(bool async) + { + await base.GroupBy_complex_key_aggregate(async); + + AssertSql( +""" +SELECT `s`.`Key`, COUNT(*) AS `Count` +FROM ( + SELECT SUBSTRING(`c`.`CustomerID`, 0 + 1, 1) AS `Key` + FROM `Orders` AS `o` + LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +) AS `s` +GROUP BY `s`.`Key` +"""); + } + + public override async Task GroupBy_complex_key_aggregate_2(bool async) + { + await base.GroupBy_complex_key_aggregate_2(async); + + AssertSql( +""" +SELECT `o0`.`Key` AS `Month`, COALESCE(SUM(`o0`.`OrderID`), 0) AS `Total`, ( + SELECT COALESCE(SUM(`o1`.`OrderID`), 0) + FROM `Orders` AS `o1` + WHERE (EXTRACT(month FROM `o1`.`OrderDate`) = `o0`.`Key`) OR (EXTRACT(month FROM `o1`.`OrderDate`) IS NULL AND (`o0`.`Key` IS NULL))) AS `Payment` +FROM ( + SELECT `o`.`OrderID`, EXTRACT(month FROM `o`.`OrderDate`) AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task Select_collection_of_scalar_before_GroupBy_aggregate(bool async) + { + await base.Select_collection_of_scalar_before_GroupBy_aggregate(async); + + AssertSql( +""" +SELECT `c`.`City` AS `Key`, COUNT(*) AS `Count` +FROM `Customers` AS `c` +GROUP BY `c`.`City` +"""); + } + + public override async Task GroupBy_OrderBy_key(bool async) + { + await base.GroupBy_OrderBy_key(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `c` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +ORDER BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_OrderBy_count(bool async) + { + await base.GroupBy_OrderBy_count(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `Count` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +ORDER BY COUNT(*), `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_OrderBy_count_Select_sum(bool async) + { + await base.GroupBy_OrderBy_count_Select_sum(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +ORDER BY COUNT(*), `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_aggregate_Contains(bool async) + { + await base.GroupBy_aggregate_Contains(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +WHERE EXISTS ( + SELECT 1 + FROM `Orders` AS `o0` + GROUP BY `o0`.`CustomerID` + HAVING (COUNT(*) > 30) AND ((`o0`.`CustomerID` = `o`.`CustomerID`) OR (`o0`.`CustomerID` IS NULL AND (`o`.`CustomerID` IS NULL)))) +"""); + } + + public override async Task GroupBy_aggregate_Pushdown(bool async) + { + await base.GroupBy_aggregate_Pushdown(async); + + AssertSql( +""" +@__p_0='20' +@__p_1='4' + +SELECT `o0`.`CustomerID` +FROM ( + SELECT `o`.`CustomerID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 10 + ORDER BY `o`.`CustomerID` + LIMIT @__p_0 +) AS `o0` +ORDER BY `o0`.`CustomerID` +LIMIT 18446744073709551610 OFFSET @__p_1 +"""); + } + + public override async Task GroupBy_aggregate_using_grouping_key_Pushdown(bool async) + { + await base.GroupBy_aggregate_using_grouping_key_Pushdown(async); + + AssertSql( +""" +@__p_0='20' +@__p_1='4' + +SELECT `o0`.`Key`, `o0`.`Max` +FROM ( + SELECT `o`.`CustomerID` AS `Key`, MAX(`o`.`CustomerID`) AS `Max` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 10 + ORDER BY `o`.`CustomerID` + LIMIT @__p_0 +) AS `o0` +ORDER BY `o0`.`Key` +LIMIT 18446744073709551610 OFFSET @__p_1 +"""); + } + + public override async Task GroupBy_aggregate_Pushdown_followed_by_projecting_Length(bool async) + { + await base.GroupBy_aggregate_Pushdown_followed_by_projecting_Length(async); + + AssertSql( +""" +@__p_0='20' +@__p_1='4' + +SELECT CHAR_LENGTH(`o0`.`CustomerID`) +FROM ( + SELECT `o`.`CustomerID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 10 + ORDER BY `o`.`CustomerID` + LIMIT @__p_0 +) AS `o0` +ORDER BY `o0`.`CustomerID` +LIMIT 18446744073709551610 OFFSET @__p_1 +"""); + } + + public override async Task GroupBy_aggregate_Pushdown_followed_by_projecting_constant(bool async) + { + await base.GroupBy_aggregate_Pushdown_followed_by_projecting_constant(async); + + AssertSql( +""" +@__p_0='20' +@__p_1='4' + +SELECT 5 +FROM ( + SELECT `o`.`CustomerID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 10 + ORDER BY `o`.`CustomerID` + LIMIT @__p_0 +) AS `o0` +ORDER BY `o0`.`CustomerID` +LIMIT 18446744073709551610 OFFSET @__p_1 +"""); + } + + public override async Task GroupBy_filter_key(bool async) + { + await base.GroupBy_filter_key(async); + + AssertSql( +""" +SELECT `o0`.`Key`, `o0`.`c` +FROM ( + SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `c`, (`o`.`CustomerID` = 'ALFKI') AND `o`.`CustomerID` IS NOT NULL AS `c0` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID`, `c0` + HAVING `c0` +) AS `o0` +"""); + } + + public override async Task GroupBy_filter_count(bool async) + { + await base.GroupBy_filter_count(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `Count` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +HAVING COUNT(*) > 4 +"""); + } + + public override async Task GroupBy_count_filter(bool async) + { + await base.GroupBy_count_filter(async); + + AssertSql( +""" +SELECT `o0`.`Key` AS `Name`, COUNT(*) AS `Count` +FROM ( + SELECT 'Order' AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +HAVING COUNT(*) > 0 +"""); + } + + public override async Task GroupBy_filter_count_OrderBy_count_Select_sum(bool async) + { + await base.GroupBy_filter_count_OrderBy_count_Select_sum(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `Count`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +HAVING COUNT(*) > 4 +ORDER BY COUNT(*), `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Aggregate_Join(bool async) + { + await base.GroupBy_Aggregate_Join(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o1`.`OrderID`, `o1`.`CustomerID`, `o1`.`EmployeeID`, `o1`.`OrderDate` +FROM ( + SELECT `o`.`CustomerID`, MAX(`o`.`OrderID`) AS `LastOrderID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 5 +) AS `o0` +INNER JOIN `Customers` AS `c` ON `o0`.`CustomerID` = `c`.`CustomerID` +INNER JOIN `Orders` AS `o1` ON `o0`.`LastOrderID` = `o1`.`OrderID` +"""); + } + + public override async Task GroupBy_Aggregate_Join_converted_from_SelectMany(bool async) + { + await base.GroupBy_Aggregate_Join_converted_from_SelectMany(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +INNER JOIN ( + SELECT `o`.`CustomerID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 5 +) AS `o0` ON `c`.`CustomerID` = `o0`.`CustomerID` +"""); + } + + public override async Task GroupBy_Aggregate_LeftJoin_converted_from_SelectMany(bool async) + { + await base.GroupBy_Aggregate_LeftJoin_converted_from_SelectMany(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +LEFT JOIN ( + SELECT `o`.`CustomerID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 5 +) AS `o0` ON `c`.`CustomerID` = `o0`.`CustomerID` +"""); + } + + public override async Task Join_GroupBy_Aggregate_multijoins(bool async) + { + await base.Join_GroupBy_Aggregate_multijoins(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o1`.`OrderID`, `o1`.`CustomerID`, `o1`.`EmployeeID`, `o1`.`OrderDate` +FROM `Customers` AS `c` +INNER JOIN ( + SELECT `o`.`CustomerID`, MAX(`o`.`OrderID`) AS `LastOrderID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 5 +) AS `o0` ON `c`.`CustomerID` = `o0`.`CustomerID` +INNER JOIN `Orders` AS `o1` ON `o0`.`LastOrderID` = `o1`.`OrderID` +"""); + } + + public override async Task Join_GroupBy_Aggregate_single_join(bool async) + { + await base.Join_GroupBy_Aggregate_single_join(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o0`.`LastOrderID` +FROM `Customers` AS `c` +INNER JOIN ( + SELECT `o`.`CustomerID`, MAX(`o`.`OrderID`) AS `LastOrderID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 5 +) AS `o0` ON `c`.`CustomerID` = `o0`.`CustomerID` +"""); + } + + public override async Task Join_GroupBy_Aggregate_with_another_join(bool async) + { + await base.Join_GroupBy_Aggregate_with_another_join(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o0`.`LastOrderID`, `o1`.`OrderID` +FROM `Customers` AS `c` +INNER JOIN ( + SELECT `o`.`CustomerID`, MAX(`o`.`OrderID`) AS `LastOrderID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 5 +) AS `o0` ON `c`.`CustomerID` = `o0`.`CustomerID` +INNER JOIN `Orders` AS `o1` ON `c`.`CustomerID` = `o1`.`CustomerID` +"""); + } + + public override async Task Join_GroupBy_Aggregate_distinct_single_join(bool async) + { + await base.Join_GroupBy_Aggregate_distinct_single_join(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o1`.`LastOrderID` +FROM `Customers` AS `c` +INNER JOIN ( + SELECT DISTINCT `o0`.`CustomerID`, MAX(`o0`.`OrderID`) AS `LastOrderID` + FROM ( + SELECT `o`.`OrderID`, `o`.`CustomerID`, EXTRACT(year FROM `o`.`OrderDate`) AS `Year` + FROM `Orders` AS `o` + ) AS `o0` + GROUP BY `o0`.`CustomerID`, `o0`.`Year` + HAVING COUNT(*) > 5 +) AS `o1` ON `c`.`CustomerID` = `o1`.`CustomerID` +"""); + } + + public override async Task Join_GroupBy_Aggregate_with_left_join(bool async) + { + await base.Join_GroupBy_Aggregate_with_left_join(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o0`.`LastOrderID` +FROM `Customers` AS `c` +LEFT JOIN ( + SELECT `o`.`CustomerID`, MAX(`o`.`OrderID`) AS `LastOrderID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 5 +) AS `o0` ON `c`.`CustomerID` = `o0`.`CustomerID` +WHERE `c`.`CustomerID` LIKE 'A%' +"""); + } + + public override async Task Join_GroupBy_Aggregate_in_subquery(bool async) + { + await base.Join_GroupBy_Aggregate_in_subquery(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate`, `s`.`CustomerID`, `s`.`Address`, `s`.`City`, `s`.`CompanyName`, `s`.`ContactName`, `s`.`ContactTitle`, `s`.`Country`, `s`.`Fax`, `s`.`Phone`, `s`.`PostalCode`, `s`.`Region` +FROM `Orders` AS `o` +INNER JOIN ( + SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + FROM `Customers` AS `c` + INNER JOIN ( + SELECT `o0`.`CustomerID` + FROM `Orders` AS `o0` + GROUP BY `o0`.`CustomerID` + HAVING COUNT(*) > 5 + ) AS `o1` ON `c`.`CustomerID` = `o1`.`CustomerID` +) AS `s` ON `o`.`CustomerID` = `s`.`CustomerID` +WHERE `o`.`OrderID` < 10400 +"""); + } + + public override async Task Join_GroupBy_Aggregate_on_key(bool async) + { + await base.Join_GroupBy_Aggregate_on_key(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o0`.`LastOrderID` +FROM `Customers` AS `c` +INNER JOIN ( + SELECT `o`.`CustomerID` AS `Key`, MAX(`o`.`OrderID`) AS `LastOrderID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 5 +) AS `o0` ON `c`.`CustomerID` = `o0`.`Key` +"""); + } + + public override async Task GroupBy_with_result_selector(bool async) + { + await base.GroupBy_with_result_selector(async); + + AssertSql( +""" +SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `Sum`, MIN(`o`.`OrderID`) AS `Min`, MAX(`o`.`OrderID`) AS `Max`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Sum_constant(bool async) + { + await base.GroupBy_Sum_constant(async); + + AssertSql( +""" +SELECT COALESCE(SUM(1), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Sum_constant_cast(bool async) + { + await base.GroupBy_Sum_constant_cast(async); + + AssertSql( +""" +SELECT COALESCE(SUM(1), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task Distinct_GroupBy_OrderBy_key(bool async) + { + await base.Distinct_GroupBy_OrderBy_key(async); + + AssertSql( +""" +SELECT `o0`.`CustomerID` AS `Key`, COUNT(*) AS `c` +FROM ( + SELECT DISTINCT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`CustomerID` +ORDER BY `o0`.`CustomerID` +"""); + } + + public override async Task Select_uncorrelated_collection_with_groupby_works(bool async) + { + await base.Select_uncorrelated_collection_with_groupby_works(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `o0`.`OrderID` +FROM `Customers` AS `c` +LEFT JOIN LATERAL ( + SELECT `o`.`OrderID` + FROM `Orders` AS `o` + GROUP BY `o`.`OrderID` +) AS `o0` ON TRUE +WHERE `c`.`CustomerID` LIKE 'A%' +ORDER BY `c`.`CustomerID` +"""); + } + + public override async Task Select_uncorrelated_collection_with_groupby_multiple_collections_work(bool async) + { + await base.Select_uncorrelated_collection_with_groupby_multiple_collections_work(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `p1`.`ProductID`, `p2`.`c`, `p2`.`ProductID` +FROM `Orders` AS `o` +LEFT JOIN LATERAL ( + SELECT `p`.`ProductID` + FROM `Products` AS `p` + GROUP BY `p`.`ProductID` +) AS `p1` ON TRUE +LEFT JOIN LATERAL ( + SELECT COUNT(*) AS `c`, `p0`.`ProductID` + FROM `Products` AS `p0` + GROUP BY `p0`.`ProductID` +) AS `p2` ON TRUE +WHERE `o`.`CustomerID` LIKE 'A%' +ORDER BY `o`.`OrderID`, `p1`.`ProductID` +"""); + } + + public override async Task Select_GroupBy_All(bool async) + { + await base.Select_GroupBy_All(async); + + AssertSql( +""" +SELECT NOT EXISTS ( + SELECT 1 + FROM ( + SELECT (`o`.`CustomerID` <> 'ALFKI') OR `o`.`CustomerID` IS NULL AS `c` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID`, `c` + HAVING `c` + ) AS `o0`) +"""); + } + + public override async Task GroupBy_multiple_Count_with_predicate(bool async) + { + await base.GroupBy_multiple_Count_with_predicate(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, COUNT(*) AS `All`, COUNT(CASE + WHEN `o`.`OrderID` < 11000 THEN 1 +END) AS `TenK`, COUNT(CASE + WHEN `o`.`OrderID` < 12000 THEN 1 +END) AS `EleventK` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_multiple_Sum_with_conditional_projection(bool async) + { + await base.GroupBy_multiple_Sum_with_conditional_projection(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, COALESCE(SUM(CASE + WHEN `o`.`OrderID` < 11000 THEN `o`.`OrderID` + ELSE 0 +END), 0) AS `TenK`, COALESCE(SUM(CASE + WHEN `o`.`OrderID` >= 11000 THEN `o`.`OrderID` + ELSE 0 +END), 0) AS `EleventK` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Key_as_part_of_element_selector(bool async) + { + await base.GroupBy_Key_as_part_of_element_selector(async); + + AssertSql( +""" +SELECT `o`.`OrderID` AS `Key`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg`, MAX(`o`.`OrderDate`) AS `Max` +FROM `Orders` AS `o` +GROUP BY `o`.`OrderID` +"""); + } + + public override async Task GroupBy_composite_Key_as_part_of_element_selector(bool async) + { + await base.GroupBy_composite_Key_as_part_of_element_selector(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, AVG(CAST(`o`.`OrderID` AS double)) AS `Avg`, MAX(`o`.`OrderDate`) AS `Max` +FROM `Orders` AS `o` +GROUP BY `o`.`OrderID`, `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_with_order_by_skip_and_another_order_by(bool async) + { + await base.GroupBy_with_order_by_skip_and_another_order_by(async); + + AssertSql( +""" +@__p_0='80' + +SELECT COALESCE(SUM(`o0`.`OrderID`), 0) +FROM ( + SELECT `o`.`OrderID`, `o`.`CustomerID` + FROM `Orders` AS `o` + ORDER BY `o`.`CustomerID`, `o`.`OrderID` + LIMIT 18446744073709551610 OFFSET @__p_0 +) AS `o0` +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_Count_with_predicate(bool async) + { + await base.GroupBy_Property_Select_Count_with_predicate(async); + + AssertSql( +""" +SELECT COUNT(CASE + WHEN `o`.`OrderID` < 10300 THEN 1 +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Property_Select_LongCount_with_predicate(bool async) + { + await base.GroupBy_Property_Select_LongCount_with_predicate(async); + + AssertSql( +""" +SELECT COUNT(CASE + WHEN `o`.`OrderID` < 10300 THEN 1 +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_orderby_projection_with_coalesce_operation(bool async) + { + await base.GroupBy_orderby_projection_with_coalesce_operation(async); + + AssertSql( +""" +SELECT COALESCE(`c`.`City`, 'Unknown') AS `Locality`, COUNT(*) AS `Count` +FROM `Customers` AS `c` +GROUP BY `c`.`City` +ORDER BY COUNT(*) DESC, `c`.`City` +"""); + } + + public override async Task GroupBy_let_orderby_projection_with_coalesce_operation(bool async) + { + await base.GroupBy_let_orderby_projection_with_coalesce_operation(async); + + AssertSql(); + } + + public override async Task GroupBy_Min_Where_optional_relationship(bool async) + { + await base.GroupBy_Min_Where_optional_relationship(async); + + AssertSql( +""" +SELECT `c`.`CustomerID` AS `Key`, COUNT(*) AS `Count` +FROM `Orders` AS `o` +LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +GROUP BY `c`.`CustomerID` +HAVING COUNT(*) <> 2 +"""); + } + + public override async Task GroupBy_Min_Where_optional_relationship_2(bool async) + { + await base.GroupBy_Min_Where_optional_relationship_2(async); + + AssertSql( +""" +SELECT `c`.`CustomerID` AS `Key`, COUNT(*) AS `Count` +FROM `Orders` AS `o` +LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +GROUP BY `c`.`CustomerID` +HAVING (COUNT(*) < 2) OR (COUNT(*) > 2) +"""); + } + + public override async Task GroupBy_aggregate_over_a_subquery(bool async) + { + await base.GroupBy_aggregate_over_a_subquery(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, ( + SELECT COUNT(*) + FROM `Customers` AS `c` + WHERE `c`.`CustomerID` = `o`.`CustomerID`) AS `Count` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_aggregate_join_with_grouping_key(bool async) + { + await base.GroupBy_aggregate_join_with_grouping_key(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o0`.`Count` +FROM ( + SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `Count` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o0` +INNER JOIN `Customers` AS `c` ON `o0`.`Key` = `c`.`CustomerID` +"""); + } + + public override async Task GroupBy_aggregate_join_with_group_result(bool async) + { + await base.GroupBy_aggregate_join_with_group_result(async); + + AssertSql( +""" +SELECT `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate` +FROM ( + SELECT `o`.`CustomerID` AS `Key`, MAX(`o`.`OrderDate`) AS `LastOrderDate` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o1` +INNER JOIN `Orders` AS `o0` ON ((`o1`.`Key` = `o0`.`CustomerID`) OR (`o1`.`Key` IS NULL AND (`o0`.`CustomerID` IS NULL))) AND ((`o1`.`LastOrderDate` = `o0`.`OrderDate`) OR (`o1`.`LastOrderDate` IS NULL AND (`o0`.`OrderDate` IS NULL))) +"""); + } + + public override async Task GroupBy_aggregate_from_right_side_of_join(bool async) + { + await base.GroupBy_aggregate_from_right_side_of_join(async); + + AssertSql( +""" +@__p_0='10' + +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o0`.`Max` +FROM `Customers` AS `c` +INNER JOIN ( + SELECT `o`.`CustomerID` AS `Key`, MAX(`o`.`OrderDate`) AS `Max` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o0` ON `c`.`CustomerID` = `o0`.`Key` +ORDER BY `o0`.`Max`, `c`.`CustomerID` +LIMIT @__p_0 OFFSET @__p_0 +"""); + } + + public override async Task GroupBy_aggregate_join_another_GroupBy_aggregate(bool async) + { + await base.GroupBy_aggregate_join_another_GroupBy_aggregate(async); + + AssertSql( +""" +SELECT `o1`.`Key`, `o1`.`Total`, `o2`.`ThatYear` +FROM ( + SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `Total` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o1` +INNER JOIN ( + SELECT `o0`.`CustomerID` AS `Key`, COUNT(*) AS `ThatYear` + FROM `Orders` AS `o0` + WHERE EXTRACT(year FROM `o0`.`OrderDate`) = 1997 + GROUP BY `o0`.`CustomerID` +) AS `o2` ON `o1`.`Key` = `o2`.`Key` +"""); + } + + public override async Task GroupBy_aggregate_after_skip_0_take_0(bool async) + { + await base.GroupBy_aggregate_after_skip_0_take_0(async); + + AssertSql( + AppConfig.ServerVersion.Supports.MySqlBugLimit0Offset0ExistsWorkaround + ? """ +SELECT `o0`.`CustomerID` AS `Key`, COUNT(*) AS `Total` +FROM ( + SELECT `o`.`CustomerID` + FROM `Orders` AS `o` + WHERE FALSE +) AS `o0` +GROUP BY `o0`.`CustomerID` +""" + : """ +@__p_0='0' + +SELECT `o0`.`CustomerID` AS `Key`, COUNT(*) AS `Total` +FROM ( + SELECT `o`.`CustomerID` + FROM `Orders` AS `o` + LIMIT @__p_0 OFFSET @__p_0 +) AS `o0` +GROUP BY `o0`.`CustomerID` +"""); + } + + public override async Task GroupBy_skip_0_take_0_aggregate(bool async) + { + await base.GroupBy_skip_0_take_0_aggregate(async); + + AssertSql( + AppConfig.ServerVersion.Supports.MySqlBugLimit0Offset0ExistsWorkaround + ? """ +SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `Total` +FROM `Orders` AS `o` +WHERE `o`.`OrderID` > 10500 +GROUP BY `o`.`CustomerID` +HAVING FALSE +""" + : """ +@__p_0='0' + +SELECT `o`.`CustomerID` AS `Key`, COUNT(*) AS `Total` +FROM `Orders` AS `o` +WHERE `o`.`OrderID` > 10500 +GROUP BY `o`.`CustomerID` +LIMIT @__p_0 OFFSET @__p_0 +"""); + } + + public override async Task GroupBy_aggregate_followed_another_GroupBy_aggregate(bool async) + { + await base.GroupBy_aggregate_followed_another_GroupBy_aggregate(async); + + AssertSql( +""" +SELECT `o1`.`CustomerID` AS `Key`, COUNT(*) AS `Count` +FROM ( + SELECT `o0`.`CustomerID` + FROM ( + SELECT `o`.`CustomerID`, EXTRACT(year FROM `o`.`OrderDate`) AS `Year` + FROM `Orders` AS `o` + ) AS `o0` + GROUP BY `o0`.`CustomerID`, `o0`.`Year` +) AS `o1` +GROUP BY `o1`.`CustomerID` +"""); + } + + public override async Task GroupBy_aggregate_SelectMany(bool async) + { + await base.GroupBy_aggregate_SelectMany(async); + + AssertSql(); + } + + public override async Task GroupBy_aggregate_without_selectMany_selecting_first(bool async) + { + await base.GroupBy_aggregate_without_selectMany_selecting_first(async); + + AssertSql( +""" +SELECT `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate` +FROM ( + SELECT MIN(`o`.`OrderID`) AS `c` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o1` +CROSS JOIN `Orders` AS `o0` +WHERE `o0`.`OrderID` = `o1`.`c` +"""); + } + + public override async Task GroupBy_aggregate_left_join_GroupBy_aggregate_left_join(bool async) + { + await base.GroupBy_aggregate_left_join_GroupBy_aggregate_left_join(async); + + AssertSql(); + } + + public override async Task GroupBy_Where_Average(bool async) + { + await base.GroupBy_Where_Average(async); + + AssertSql( +""" +SELECT AVG(CASE + WHEN `o`.`OrderID` < 10300 THEN CAST(`o`.`OrderID` AS double) +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_Count(bool async) + { + await base.GroupBy_Where_Count(async); + + AssertSql( +""" +SELECT COUNT(CASE + WHEN `o`.`OrderID` < 10300 THEN 1 +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_LongCount(bool async) + { + await base.GroupBy_Where_LongCount(async); + + AssertSql( +""" +SELECT COUNT(CASE + WHEN `o`.`OrderID` < 10300 THEN 1 +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_Max(bool async) + { + await base.GroupBy_Where_Max(async); + + AssertSql( +""" +SELECT MAX(CASE + WHEN `o`.`OrderID` < 10300 THEN `o`.`OrderID` +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_Min(bool async) + { + await base.GroupBy_Where_Min(async); + + AssertSql( +""" +SELECT MIN(CASE + WHEN `o`.`OrderID` < 10300 THEN `o`.`OrderID` +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_Sum(bool async) + { + await base.GroupBy_Where_Sum(async); + + AssertSql( +""" +SELECT COALESCE(SUM(CASE + WHEN `o`.`OrderID` < 10300 THEN `o`.`OrderID` +END), 0) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_Count_with_predicate(bool async) + { + await base.GroupBy_Where_Count_with_predicate(async); + + AssertSql( +""" +SELECT COUNT(CASE + WHEN (`o`.`OrderID` < 10300) AND (`o`.`OrderDate` IS NOT NULL AND (EXTRACT(year FROM `o`.`OrderDate`) = 1997)) THEN 1 +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_Where_Count(bool async) + { + await base.GroupBy_Where_Where_Count(async); + + AssertSql( +""" +SELECT COUNT(CASE + WHEN (`o`.`OrderID` < 10300) AND (`o`.`OrderDate` IS NOT NULL AND (EXTRACT(year FROM `o`.`OrderDate`) = 1997)) THEN 1 +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_Select_Where_Count(bool async) + { + await base.GroupBy_Where_Select_Where_Count(async); + + AssertSql( +""" +SELECT COUNT(CASE + WHEN (`o`.`OrderID` < 10300) AND (`o`.`OrderDate` IS NOT NULL AND (EXTRACT(year FROM `o`.`OrderDate`) = 1997)) THEN 1 +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_Select_Where_Select_Min(bool async) + { + await base.GroupBy_Where_Select_Where_Select_Min(async); + + AssertSql( +""" +SELECT MIN(CASE + WHEN (`o`.`OrderID` < 10300) AND (`o`.`OrderDate` IS NOT NULL AND (EXTRACT(year FROM `o`.`OrderDate`) = 1997)) THEN `o`.`OrderID` +END) +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_multiple_Sum_with_Select_conditional_projection(bool async) + { + await base.GroupBy_multiple_Sum_with_Select_conditional_projection(async); + + AssertSql( +""" +SELECT `o`.`CustomerID`, COALESCE(SUM(CASE + WHEN `o`.`OrderID` < 11000 THEN `o`.`OrderID` + ELSE 0 +END), 0) AS `TenK`, COALESCE(SUM(CASE + WHEN `o`.`OrderID` >= 11000 THEN `o`.`OrderID` + ELSE 0 +END), 0) AS `EleventK` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task LongCount_after_GroupBy_aggregate(bool async) + { + await base.LongCount_after_GroupBy_aggregate(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o0` +"""); + } + + public override async Task GroupBy_Select_Distinct_aggregate(bool async) + { + await base.GroupBy_Select_Distinct_aggregate(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, AVG(DISTINCT (CAST(`o`.`OrderID` AS double))) AS `Average`, COUNT(DISTINCT (`o`.`EmployeeID`)) AS `Count`, COUNT(DISTINCT (`o`.`EmployeeID`)) AS `LongCount`, MAX(DISTINCT (`o`.`OrderDate`)) AS `Max`, MIN(DISTINCT (`o`.`OrderDate`)) AS `Min`, COALESCE(SUM(DISTINCT (`o`.`OrderID`)), 0) AS `Sum` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task Final_GroupBy_property_entity(bool async) + { + await base.Final_GroupBy_property_entity(async); + + AssertSql( +""" +SELECT `c`.`City`, `c`.`CustomerID`, `c`.`Address`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +ORDER BY `c`.`City` +"""); + } + + public override async Task Final_GroupBy_entity(bool async) + { + await base.Final_GroupBy_entity(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Orders` AS `o` +LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` +WHERE `o`.`OrderID` < 10500 +ORDER BY `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +"""); + } + + public override async Task Final_GroupBy_property_entity_non_nullable(bool async) + { + await base.Final_GroupBy_property_entity_non_nullable(async); + + AssertSql( +""" +SELECT `o`.`OrderID`, `o`.`ProductID`, `o`.`Discount`, `o`.`Quantity`, `o`.`UnitPrice` +FROM `Order Details` AS `o` +WHERE `o`.`OrderID` < 10500 +ORDER BY `o`.`OrderID` +"""); + } + + public override async Task Final_GroupBy_property_anonymous_type(bool async) + { + await base.Final_GroupBy_property_anonymous_type(async); + + AssertSql( +""" +SELECT `c`.`City`, `c`.`ContactName`, `c`.`ContactTitle` +FROM `Customers` AS `c` +ORDER BY `c`.`City` +"""); + } + + public override async Task Final_GroupBy_multiple_properties_entity(bool async) + { + await base.Final_GroupBy_multiple_properties_entity(async); + + AssertSql( +""" +SELECT `c`.`City`, `c`.`Region`, `c`.`CustomerID`, `c`.`Address`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode` +FROM `Customers` AS `c` +ORDER BY `c`.`City`, `c`.`Region` +"""); + } + + public override async Task Final_GroupBy_complex_key_entity(bool async) + { + await base.Final_GroupBy_complex_key_entity(async); + + AssertSql( +""" +SELECT `c0`.`City`, `c0`.`Region`, `c0`.`Constant`, `c0`.`CustomerID`, `c0`.`Address`, `c0`.`CompanyName`, `c0`.`ContactName`, `c0`.`ContactTitle`, `c0`.`Country`, `c0`.`Fax`, `c0`.`Phone`, `c0`.`PostalCode` +FROM ( + SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, 1 AS `Constant` + FROM `Customers` AS `c` +) AS `c0` +ORDER BY `c0`.`City`, `c0`.`Region`, `c0`.`Constant` +"""); + } + + public override async Task Final_GroupBy_nominal_type_entity(bool async) + { + await base.Final_GroupBy_nominal_type_entity(async); + + AssertSql( +""" +SELECT `c0`.`City`, `c0`.`Constant`, `c0`.`CustomerID`, `c0`.`Address`, `c0`.`CompanyName`, `c0`.`ContactName`, `c0`.`ContactTitle`, `c0`.`Country`, `c0`.`Fax`, `c0`.`Phone`, `c0`.`PostalCode`, `c0`.`Region` +FROM ( + SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, 1 AS `Constant` + FROM `Customers` AS `c` +) AS `c0` +ORDER BY `c0`.`City`, `c0`.`Constant` +"""); + } + + public override async Task Final_GroupBy_property_anonymous_type_element_selector(bool async) + { + await base.Final_GroupBy_property_anonymous_type_element_selector(async); + + AssertSql( +""" +SELECT `c`.`City`, `c`.`ContactName`, `c`.`ContactTitle` +FROM `Customers` AS `c` +ORDER BY `c`.`City` +"""); + } + + public override async Task Final_GroupBy_property_entity_Include_collection(bool async) + { + await base.Final_GroupBy_property_entity_Include_collection(async); + + AssertSql( +""" +SELECT `c`.`City`, `c`.`CustomerID`, `c`.`Address`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Customers` AS `c` +LEFT JOIN `Orders` AS `o` ON `c`.`CustomerID` = `o`.`CustomerID` +WHERE `c`.`Country` = 'USA' +ORDER BY `c`.`City`, `c`.`CustomerID` +"""); + } + + public override async Task Final_GroupBy_property_entity_projecting_collection(bool async) + { + await base.Final_GroupBy_property_entity_projecting_collection(async); + + AssertSql( +""" +SELECT `c`.`City`, `c`.`CustomerID`, `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM `Customers` AS `c` +LEFT JOIN `Orders` AS `o` ON `c`.`CustomerID` = `o`.`CustomerID` +WHERE `c`.`Country` = 'USA' +ORDER BY `c`.`City`, `c`.`CustomerID` +"""); + } + + public override async Task Final_GroupBy_property_entity_projecting_collection_composed(bool async) + { + await base.Final_GroupBy_property_entity_projecting_collection_composed(async); + + AssertSql( +""" +SELECT `c`.`City`, `c`.`CustomerID`, `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate` +FROM `Customers` AS `c` +LEFT JOIN ( + SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + FROM `Orders` AS `o` + WHERE `o`.`OrderID` < 11000 +) AS `o0` ON `c`.`CustomerID` = `o0`.`CustomerID` +WHERE `c`.`Country` = 'USA' +ORDER BY `c`.`City`, `c`.`CustomerID` +"""); + } + + public override async Task Final_GroupBy_property_entity_projecting_collection_and_single_result(bool async) + { + await base.Final_GroupBy_property_entity_projecting_collection_and_single_result(async); + + AssertSql( +""" +SELECT `c`.`City`, `c`.`CustomerID`, `o1`.`OrderID`, `o1`.`CustomerID`, `o1`.`EmployeeID`, `o1`.`OrderDate`, `o3`.`OrderID`, `o3`.`CustomerID`, `o3`.`EmployeeID`, `o3`.`OrderDate` +FROM `Customers` AS `c` +LEFT JOIN ( + SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` + FROM `Orders` AS `o` + WHERE `o`.`OrderID` < 11000 +) AS `o1` ON `c`.`CustomerID` = `o1`.`CustomerID` +LEFT JOIN ( + SELECT `o2`.`OrderID`, `o2`.`CustomerID`, `o2`.`EmployeeID`, `o2`.`OrderDate` + FROM ( + SELECT `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate`, ROW_NUMBER() OVER(PARTITION BY `o0`.`CustomerID` ORDER BY `o0`.`OrderDate` DESC) AS `row` + FROM `Orders` AS `o0` + ) AS `o2` + WHERE `o2`.`row` <= 1 +) AS `o3` ON `c`.`CustomerID` = `o3`.`CustomerID` +WHERE `c`.`Country` = 'USA' +ORDER BY `c`.`City`, `c`.`CustomerID` +"""); + } + + public override async Task GroupBy_Where_with_grouping_result(bool async) + { + await base.GroupBy_Where_with_grouping_result(async); + + AssertSql(); + } + + public override async Task GroupBy_OrderBy_with_grouping_result(bool async) + { + await base.GroupBy_OrderBy_with_grouping_result(async); + + AssertSql(); + } + + public override async Task GroupBy_SelectMany(bool async) + { + await base.GroupBy_SelectMany(async); + + AssertSql(); + } + + public override async Task OrderBy_GroupBy_SelectMany(bool async) + { + await base.OrderBy_GroupBy_SelectMany(async); + + AssertSql(); + } + + public override async Task OrderBy_GroupBy_SelectMany_shadow(bool async) + { + await base.OrderBy_GroupBy_SelectMany_shadow(async); + + AssertSql(); + } + + public override async Task GroupBy_with_orderby_take_skip_distinct_followed_by_group_key_projection(bool async) + { + await base.GroupBy_with_orderby_take_skip_distinct_followed_by_group_key_projection(async); + + AssertSql(); + } + + public override async Task GroupBy_Distinct(bool async) + { + await base.GroupBy_Distinct(async); + + AssertSql(); + } + + public override async Task GroupBy_complex_key_without_aggregate(bool async) + { + await base.GroupBy_complex_key_without_aggregate(async); + + AssertSql( +""" +SELECT `s1`.`Key`, `s3`.`OrderID`, `s3`.`CustomerID`, `s3`.`EmployeeID`, `s3`.`OrderDate`, `s3`.`CustomerID0` +FROM ( + SELECT `s`.`Key` + FROM ( + SELECT SUBSTRING(`c`.`CustomerID`, 0 + 1, 1) AS `Key` + FROM `Orders` AS `o` + LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` + ) AS `s` + GROUP BY `s`.`Key` +) AS `s1` +LEFT JOIN ( + SELECT `s2`.`OrderID`, `s2`.`CustomerID`, `s2`.`EmployeeID`, `s2`.`OrderDate`, `s2`.`CustomerID0`, `s2`.`Key` + FROM ( + SELECT `s0`.`OrderID`, `s0`.`CustomerID`, `s0`.`EmployeeID`, `s0`.`OrderDate`, `s0`.`CustomerID0`, `s0`.`Key`, ROW_NUMBER() OVER(PARTITION BY `s0`.`Key` ORDER BY `s0`.`OrderID`, `s0`.`CustomerID0`) AS `row` + FROM ( + SELECT `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate`, `c0`.`CustomerID` AS `CustomerID0`, SUBSTRING(`c0`.`CustomerID`, 0 + 1, 1) AS `Key` + FROM `Orders` AS `o0` + LEFT JOIN `Customers` AS `c0` ON `o0`.`CustomerID` = `c0`.`CustomerID` + ) AS `s0` + ) AS `s2` + WHERE (1 < `s2`.`row`) AND (`s2`.`row` <= 3) +) AS `s3` ON `s1`.`Key` = `s3`.`Key` +ORDER BY `s1`.`Key`, `s3`.`OrderID` +"""); + } + + public override async Task GroupBy_selecting_grouping_key_list(bool async) + { + await base.GroupBy_selecting_grouping_key_list(async); + + AssertSql( +""" +SELECT `o1`.`CustomerID`, `o0`.`CustomerID`, `o0`.`OrderID` +FROM ( + SELECT `o`.`CustomerID` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o1` +LEFT JOIN `Orders` AS `o0` ON `o1`.`CustomerID` = `o0`.`CustomerID` +ORDER BY `o1`.`CustomerID` +"""); + } + + public override async Task Select_GroupBy_SelectMany(bool async) + { + await base.Select_GroupBy_SelectMany(async); + + AssertSql(); + } + + public override async Task GroupBy_Shadow(bool async) + { + await base.GroupBy_Shadow(async); + + AssertSql( +""" +SELECT ( + SELECT `e0`.`Title` + FROM `Employees` AS `e0` + WHERE ((`e0`.`Title` = 'Sales Representative') AND (`e0`.`EmployeeID` = 1)) AND ((`e`.`Title` = `e0`.`Title`) OR (`e`.`Title` IS NULL AND (`e0`.`Title` IS NULL))) + LIMIT 1) +FROM `Employees` AS `e` +WHERE (`e`.`Title` = 'Sales Representative') AND (`e`.`EmployeeID` = 1) +GROUP BY `e`.`Title` +"""); + } + + public override async Task GroupBy_Shadow2(bool async) + { + await base.GroupBy_Shadow2(async); + + AssertSql( +""" +SELECT `e3`.`EmployeeID`, `e3`.`City`, `e3`.`Country`, `e3`.`FirstName`, `e3`.`ReportsTo`, `e3`.`Title` +FROM ( + SELECT `e`.`Title` + FROM `Employees` AS `e` + WHERE (`e`.`Title` = 'Sales Representative') AND (`e`.`EmployeeID` = 1) + GROUP BY `e`.`Title` +) AS `e1` +LEFT JOIN ( + SELECT `e2`.`EmployeeID`, `e2`.`City`, `e2`.`Country`, `e2`.`FirstName`, `e2`.`ReportsTo`, `e2`.`Title` + FROM ( + SELECT `e0`.`EmployeeID`, `e0`.`City`, `e0`.`Country`, `e0`.`FirstName`, `e0`.`ReportsTo`, `e0`.`Title`, ROW_NUMBER() OVER(PARTITION BY `e0`.`Title` ORDER BY `e0`.`EmployeeID`) AS `row` + FROM `Employees` AS `e0` + WHERE (`e0`.`Title` = 'Sales Representative') AND (`e0`.`EmployeeID` = 1) + ) AS `e2` + WHERE `e2`.`row` <= 1 +) AS `e3` ON `e1`.`Title` = `e3`.`Title` +"""); + } + + public override async Task GroupBy_Shadow3(bool async) + { + await base.GroupBy_Shadow3(async); + + AssertSql( +""" +SELECT ( + SELECT `e0`.`Title` + FROM `Employees` AS `e0` + WHERE (`e0`.`EmployeeID` = 1) AND (`e`.`EmployeeID` = `e0`.`EmployeeID`) + LIMIT 1) +FROM `Employees` AS `e` +WHERE `e`.`EmployeeID` = 1 +GROUP BY `e`.`EmployeeID` +"""); + } + + public override async Task GroupBy_select_grouping_list(bool async) + { + await base.GroupBy_select_grouping_list(async); + + AssertSql( +""" +SELECT `c1`.`City`, `c0`.`CustomerID`, `c0`.`Address`, `c0`.`City`, `c0`.`CompanyName`, `c0`.`ContactName`, `c0`.`ContactTitle`, `c0`.`Country`, `c0`.`Fax`, `c0`.`Phone`, `c0`.`PostalCode`, `c0`.`Region` +FROM ( + SELECT `c`.`City` + FROM `Customers` AS `c` + GROUP BY `c`.`City` +) AS `c1` +LEFT JOIN `Customers` AS `c0` ON `c1`.`City` = `c0`.`City` +ORDER BY `c1`.`City` +"""); + } + + public override async Task GroupBy_select_grouping_array(bool async) + { + await base.GroupBy_select_grouping_array(async); + + AssertSql( +""" +SELECT `c1`.`City`, `c0`.`CustomerID`, `c0`.`Address`, `c0`.`City`, `c0`.`CompanyName`, `c0`.`ContactName`, `c0`.`ContactTitle`, `c0`.`Country`, `c0`.`Fax`, `c0`.`Phone`, `c0`.`PostalCode`, `c0`.`Region` +FROM ( + SELECT `c`.`City` + FROM `Customers` AS `c` + GROUP BY `c`.`City` +) AS `c1` +LEFT JOIN `Customers` AS `c0` ON `c1`.`City` = `c0`.`City` +ORDER BY `c1`.`City` +"""); + } + + public override async Task GroupBy_select_grouping_composed_list(bool async) + { + await base.GroupBy_select_grouping_composed_list(async); + + AssertSql( +""" +SELECT `c1`.`City`, `c2`.`CustomerID`, `c2`.`Address`, `c2`.`City`, `c2`.`CompanyName`, `c2`.`ContactName`, `c2`.`ContactTitle`, `c2`.`Country`, `c2`.`Fax`, `c2`.`Phone`, `c2`.`PostalCode`, `c2`.`Region` +FROM ( + SELECT `c`.`City` + FROM `Customers` AS `c` + GROUP BY `c`.`City` +) AS `c1` +LEFT JOIN ( + SELECT `c0`.`CustomerID`, `c0`.`Address`, `c0`.`City`, `c0`.`CompanyName`, `c0`.`ContactName`, `c0`.`ContactTitle`, `c0`.`Country`, `c0`.`Fax`, `c0`.`Phone`, `c0`.`PostalCode`, `c0`.`Region` + FROM `Customers` AS `c0` + WHERE `c0`.`CustomerID` LIKE 'A%' +) AS `c2` ON `c1`.`City` = `c2`.`City` +ORDER BY `c1`.`City` +"""); + } + + public override async Task GroupBy_select_grouping_composed_list_2(bool async) + { + await base.GroupBy_select_grouping_composed_list_2(async); + + AssertSql( +""" +SELECT `c1`.`City`, `c0`.`CustomerID`, `c0`.`Address`, `c0`.`City`, `c0`.`CompanyName`, `c0`.`ContactName`, `c0`.`ContactTitle`, `c0`.`Country`, `c0`.`Fax`, `c0`.`Phone`, `c0`.`PostalCode`, `c0`.`Region` +FROM ( + SELECT `c`.`City` + FROM `Customers` AS `c` + GROUP BY `c`.`City` +) AS `c1` +LEFT JOIN `Customers` AS `c0` ON `c1`.`City` = `c0`.`City` +ORDER BY `c1`.`City`, `c0`.`CustomerID` +"""); + } + + public override async Task GroupBy_with_group_key_being_navigation(bool async) + { + await base.GroupBy_with_group_key_being_navigation(async); + + AssertSql( +""" +SELECT `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Aggregate` +FROM `Order Details` AS `o` +INNER JOIN `Orders` AS `o0` ON `o`.`OrderID` = `o0`.`OrderID` +GROUP BY `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate` +"""); + } + + public override async Task GroupBy_with_group_key_being_nested_navigation(bool async) + { + await base.GroupBy_with_group_key_being_nested_navigation(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region`, COALESCE(SUM(`o`.`OrderID`), 0) AS `Aggregate` +FROM `Order Details` AS `o` +INNER JOIN `Orders` AS `o0` ON `o`.`OrderID` = `o0`.`OrderID` +LEFT JOIN `Customers` AS `c` ON `o0`.`CustomerID` = `c`.`CustomerID` +GROUP BY `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +"""); + } + + public override async Task GroupBy_with_group_key_being_navigation_with_entity_key_projection(bool async) + { + await base.GroupBy_with_group_key_being_navigation_with_entity_key_projection(async); + + AssertSql( +""" +SELECT `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate` +FROM `Order Details` AS `o` +INNER JOIN `Orders` AS `o0` ON `o`.`OrderID` = `o0`.`OrderID` +GROUP BY `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate` +"""); + } + + public override async Task GroupBy_with_group_key_being_navigation_with_complex_projection(bool async) + { + await base.GroupBy_with_group_key_being_navigation_with_complex_projection(async); + + AssertSql(); + } + + public override async Task Count_after_GroupBy_aggregate(bool async) + { + await base.Count_after_GroupBy_aggregate(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o0` +"""); + } + + public override async Task MinMax_after_GroupBy_aggregate(bool async) + { + await base.MinMax_after_GroupBy_aggregate(async); + + AssertSql( +""" +SELECT MIN(`o0`.`c`) +FROM ( + SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `c` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o0` +""", + // + """ +SELECT MAX(`o0`.`c`) +FROM ( + SELECT COALESCE(SUM(`o`.`OrderID`), 0) AS `c` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o0` +"""); + } + + public override async Task All_after_GroupBy_aggregate(bool async) + { + await base.All_after_GroupBy_aggregate(async); + + AssertSql( +""" +SELECT NOT EXISTS ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING FALSE) +"""); + } + + public override async Task All_after_GroupBy_aggregate2(bool async) + { + await base.All_after_GroupBy_aggregate2(async); + + AssertSql( +""" +SELECT NOT EXISTS ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COALESCE(SUM(`o`.`OrderID`), 0) < 0) +"""); + } + + public override async Task Any_after_GroupBy_aggregate(bool async) + { + await base.Any_after_GroupBy_aggregate(async); + + AssertSql( +""" +SELECT EXISTS ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID`) +"""); + } + + public override async Task Count_after_GroupBy_without_aggregate(bool async) + { + await base.Count_after_GroupBy_without_aggregate(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o0` +"""); + } + + public override async Task Count_with_predicate_after_GroupBy_without_aggregate(bool async) + { + await base.Count_with_predicate_after_GroupBy_without_aggregate(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 1 +) AS `o0` +"""); + } + + public override async Task LongCount_after_GroupBy_without_aggregate(bool async) + { + await base.LongCount_after_GroupBy_without_aggregate(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o0` +"""); + } + + public override async Task LongCount_with_predicate_after_GroupBy_without_aggregate(bool async) + { + await base.LongCount_with_predicate_after_GroupBy_without_aggregate(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 1 +) AS `o0` +"""); + } + + public override async Task Any_after_GroupBy_without_aggregate(bool async) + { + await base.Any_after_GroupBy_without_aggregate(async); + + AssertSql( +""" +SELECT EXISTS ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID`) +"""); + } + + public override async Task Any_with_predicate_after_GroupBy_without_aggregate(bool async) + { + await base.Any_with_predicate_after_GroupBy_without_aggregate(async); + + AssertSql( +""" +SELECT EXISTS ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) > 1) +"""); + } + + public override async Task All_with_predicate_after_GroupBy_without_aggregate(bool async) + { + await base.All_with_predicate_after_GroupBy_without_aggregate(async); + + AssertSql( +""" +SELECT NOT EXISTS ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + HAVING COUNT(*) <= 1) +"""); + } + + public override async Task GroupBy_aggregate_followed_by_another_GroupBy_aggregate(bool async) + { + await base.GroupBy_aggregate_followed_by_another_GroupBy_aggregate(async); + + AssertSql( +""" +SELECT `o1`.`Key0` AS `Key`, COALESCE(SUM(`o1`.`Count`), 0) AS `Count` +FROM ( + SELECT `o0`.`Count`, 1 AS `Key0` + FROM ( + SELECT COUNT(*) AS `Count` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` + ) AS `o0` +) AS `o1` +GROUP BY `o1`.`Key0` +"""); + } + + public override async Task GroupBy_nominal_type_count(bool async) + { + await base.GroupBy_nominal_type_count(async); + + AssertSql( +""" +SELECT COUNT(*) +FROM ( + SELECT 1 + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID` +) AS `o0` +"""); + } + + public override async Task Complex_query_with_groupBy_in_subquery4(bool async) + { + await base.Complex_query_with_groupBy_in_subquery4(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, `s1`.`Sum`, `s1`.`Count`, `s1`.`Key` +FROM `Customers` AS `c` +LEFT JOIN LATERAL ( + SELECT COALESCE(SUM(`s`.`OrderID`), 0) AS `Sum`, ( + SELECT COUNT(*) + FROM ( + SELECT `o0`.`CustomerID`, CONCAT(COALESCE(`c1`.`City`, ''), COALESCE(`o0`.`CustomerID`, '')) AS `Key` + FROM `Orders` AS `o0` + LEFT JOIN `Customers` AS `c1` ON `o0`.`CustomerID` = `c1`.`CustomerID` + WHERE `c`.`CustomerID` = `o0`.`CustomerID` + ) AS `s0` + LEFT JOIN `Customers` AS `c2` ON `s0`.`CustomerID` = `c2`.`CustomerID` + WHERE ((`s`.`Key` = `s0`.`Key`) OR (`s`.`Key` IS NULL AND (`s0`.`Key` IS NULL))) AND (CONCAT(COALESCE(`c2`.`City`, ''), COALESCE(`s0`.`CustomerID`, '')) LIKE 'Lon%')) AS `Count`, `s`.`Key` + FROM ( + SELECT `o`.`OrderID`, CONCAT(COALESCE(`c0`.`City`, ''), COALESCE(`o`.`CustomerID`, '')) AS `Key` + FROM `Orders` AS `o` + LEFT JOIN `Customers` AS `c0` ON `o`.`CustomerID` = `c0`.`CustomerID` + WHERE `c`.`CustomerID` = `o`.`CustomerID` + ) AS `s` + GROUP BY `s`.`Key` +) AS `s1` ON TRUE +ORDER BY `c`.`CustomerID` +"""); + } + + public override async Task Complex_query_with_group_by_in_subquery5(bool async) + { + await base.Complex_query_with_group_by_in_subquery5(async); + + AssertSql( +""" +SELECT `s`.`c`, `s`.`ProductID`, `c1`.`CustomerID`, `c1`.`City` +FROM ( + SELECT COALESCE(SUM(`o`.`ProductID` + (`o`.`OrderID` * 1000)), 0) AS `c`, `o`.`ProductID`, MIN(`o`.`OrderID` / 100) AS `c0` + FROM `Order Details` AS `o` + INNER JOIN `Orders` AS `o0` ON `o`.`OrderID` = `o0`.`OrderID` + LEFT JOIN `Customers` AS `c` ON `o0`.`CustomerID` = `c`.`CustomerID` + WHERE `c`.`CustomerID` = 'ALFKI' + GROUP BY `o`.`ProductID` +) AS `s` +LEFT JOIN LATERAL ( + SELECT `c0`.`CustomerID`, `c0`.`City` + FROM `Customers` AS `c0` + WHERE CHAR_LENGTH(`c0`.`CustomerID`) < `s`.`c0` +) AS `c1` ON TRUE +ORDER BY `s`.`ProductID`, `c1`.`CustomerID` +"""); + } + + public override async Task GroupBy_scalar_subquery(bool async) + { + await base.GroupBy_scalar_subquery(async); + + AssertSql( +""" +SELECT `o0`.`Key`, COUNT(*) AS `Count` +FROM ( + SELECT ( + SELECT `c`.`ContactName` + FROM `Customers` AS `c` + WHERE `c`.`CustomerID` = `o`.`CustomerID` + LIMIT 1) AS `Key` + FROM `Orders` AS `o` +) AS `o0` +GROUP BY `o0`.`Key` +"""); + } + + public override async Task GroupBy_scalar_aggregate_in_set_operation(bool async) + { + await base.GroupBy_scalar_aggregate_in_set_operation(async); + + AssertSql( +""" +SELECT `c`.`CustomerID`, 0 AS `Sequence` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE 'F%' +UNION +SELECT `o`.`CustomerID`, 1 AS `Sequence` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_aggregate_from_multiple_query_in_same_projection(bool async) + { + await base.GroupBy_aggregate_from_multiple_query_in_same_projection(async); + + AssertSql(); + } + + public override async Task GroupBy_aggregate_from_multiple_query_in_same_projection_2(bool async) + { + await base.GroupBy_aggregate_from_multiple_query_in_same_projection_2(async); + + AssertSql( +""" +SELECT `o`.`CustomerID` AS `Key`, COALESCE(( + SELECT COUNT(*) + MIN(`o`.`OrderID`) + FROM `Employees` AS `e` + WHERE `e`.`City` = 'Seattle' + GROUP BY `e`.`City` + ORDER BY (SELECT 1) + LIMIT 1), 0) AS `A` +FROM `Orders` AS `o` +GROUP BY `o`.`CustomerID` +"""); + } + + public override async Task GroupBy_aggregate_from_multiple_query_in_same_projection_3(bool async) + { + await base.GroupBy_aggregate_from_multiple_query_in_same_projection_3(async); + + AssertSql(); + } + + public override async Task Select_uncorrelated_collection_with_groupby_when_outer_is_distinct(bool async) + { + await base.Select_uncorrelated_collection_with_groupby_when_outer_is_distinct(async); + + AssertSql( +""" +SELECT `s`.`City`, `p1`.`ProductID`, `p2`.`c`, `p2`.`ProductID` +FROM ( + SELECT DISTINCT `c`.`City` + FROM `Orders` AS `o` + LEFT JOIN `Customers` AS `c` ON `o`.`CustomerID` = `c`.`CustomerID` + WHERE `o`.`CustomerID` LIKE 'A%' +) AS `s` +LEFT JOIN LATERAL ( + SELECT `p`.`ProductID` + FROM `Products` AS `p` + GROUP BY `p`.`ProductID` +) AS `p1` ON TRUE +LEFT JOIN LATERAL ( + SELECT COUNT(*) AS `c`, `p0`.`ProductID` + FROM `Products` AS `p0` + GROUP BY `p0`.`ProductID` +) AS `p2` ON TRUE +ORDER BY `s`.`City`, `p1`.`ProductID` +"""); + } + + public override async Task Select_correlated_collection_after_GroupBy_aggregate_when_identifier_does_not_change(bool async) + { + await base.Select_correlated_collection_after_GroupBy_aggregate_when_identifier_does_not_change(async); + + AssertSql( +""" +SELECT `c0`.`CustomerID`, `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +FROM ( + SELECT `c`.`CustomerID`, `c`.`CustomerID` LIKE 'F%' AS `c` + FROM `Customers` AS `c` + GROUP BY `c`.`CustomerID`, `c` + HAVING `c` +) AS `c0` +LEFT JOIN `Orders` AS `o` ON `c0`.`CustomerID` = `o`.`CustomerID` +ORDER BY `c0`.`CustomerID` +"""); + } + + public override async Task Select_correlated_collection_after_GroupBy_aggregate_when_identifier_changes(bool async) + { + await base.Select_correlated_collection_after_GroupBy_aggregate_when_identifier_changes(async); + + AssertSql( +""" +SELECT `o1`.`CustomerID`, `o0`.`OrderID`, `o0`.`CustomerID`, `o0`.`EmployeeID`, `o0`.`OrderDate` +FROM ( + SELECT `o`.`CustomerID`, (`o`.`CustomerID` LIKE 'F%') AND `o`.`CustomerID` IS NOT NULL AS `c` + FROM `Orders` AS `o` + GROUP BY `o`.`CustomerID`, `c` + HAVING `c` +) AS `o1` +LEFT JOIN `Orders` AS `o0` ON `o1`.`CustomerID` = `o0`.`CustomerID` +ORDER BY `o1`.`CustomerID` +"""); + } + + public override async Task Select_correlated_collection_after_GroupBy_aggregate_when_identifier_changes_to_complex(bool async) + { + await base.Select_correlated_collection_after_GroupBy_aggregate_when_identifier_changes_to_complex(async); + + AssertSql( +""" +SELECT `o2`.`Key`, `o3`.`OrderID`, `o3`.`CustomerID`, `o3`.`EmployeeID`, `o3`.`OrderDate` +FROM ( + SELECT `o0`.`Key`, (`o0`.`Key` LIKE 'F%') AND `o0`.`Key` IS NOT NULL AS `c` + FROM ( + SELECT CONCAT(COALESCE(`o`.`CustomerID`, ''), 'A') AS `Key` + FROM `Orders` AS `o` + ) AS `o0` + GROUP BY `o0`.`Key`, `c` + HAVING `c` +) AS `o2` +LEFT JOIN LATERAL ( + SELECT `o1`.`OrderID`, `o1`.`CustomerID`, `o1`.`EmployeeID`, `o1`.`OrderDate` + FROM `Orders` AS `o1` + WHERE (CONCAT(COALESCE(`o1`.`CustomerID`, ''), 'A')) = `o2`.`Key` +) AS `o3` ON TRUE +ORDER BY `o2`.`Key` +"""); + } + + [SupportedServerVersionCondition(nameof(ServerVersionSupport.OuterReferenceInMultiLevelSubquery))] + public override Task GroupBy_Count_in_projection(bool async) + { + return base.GroupBy_Count_in_projection(async); + } + + [SupportedServerVersionCondition("8.0.22-mysql", "0.0.0-mariadb")] + public override Task GroupBy_group_Where_Select_Distinct_aggregate(bool async) + { + // See https://github.com/mysql-net/MySqlConnector/issues/898. + return base.GroupBy_group_Where_Select_Distinct_aggregate(async); + } + + [SupportedServerVersionCondition("8.0.0-mysql", "0.0.0-mariadb")] // Is an issue issue in MySQL 5.7.34, but not in 8.0.25. + public override Task GroupBy_constant_with_where_on_grouping_with_aggregate_operators(bool async) + { + // See https://github.com/mysql-net/MySqlConnector/issues/980. + return base.GroupBy_constant_with_where_on_grouping_with_aggregate_operators(async); + } + + [ConditionalFact] + public virtual void Check_all_tests_overridden() + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); + private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindIncludeQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindIncludeQueryMySqlTest.cs index 10000fae2..404c0003e 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindIncludeQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindIncludeQueryMySqlTest.cs @@ -22,9 +22,6 @@ public NorthwindIncludeQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - [ConditionalTheory] public override Task Include_duplicate_collection(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindJoinQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindJoinQueryMySqlTest.cs index 97b0f0c3e..4bced4161 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindJoinQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindJoinQueryMySqlTest.cs @@ -17,9 +17,6 @@ public NorthwindJoinQueryMySqlTest(NorthwindQueryMySqlFixture true; - /// /// Needs explicit ordering of views to work consistently with MySQL and MariaDB. /// But since CustomerViewModel is private, we can't even override the test case properly. diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindKeylessEntitiesQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindKeylessEntitiesQueryMySqlTest.cs index 5df5f6f22..dbb6af31c 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindKeylessEntitiesQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindKeylessEntitiesQueryMySqlTest.cs @@ -16,9 +16,6 @@ public NorthwindKeylessEntitiesQueryMySqlTest(NorthwindQueryMySqlFixture true; - public override async Task KeylessEntity_with_nav_defining_query(bool async) { // FromSql mapping. Issue #21627. diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindMiscellaneousQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindMiscellaneousQueryMySqlTest.cs index 5039792ac..5fe746fd6 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindMiscellaneousQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindMiscellaneousQueryMySqlTest.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Linq; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; @@ -30,87 +30,100 @@ public NorthwindMiscellaneousQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - public override async Task Select_bitwise_or(bool async) { await base.Select_bitwise_or(async); - AssertSql( - @"SELECT `c`.`CustomerID`, (`c`.`CustomerID` = 'ALFKI') | (`c`.`CustomerID` = 'ANATR') AS `Value` + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`CustomerID` IN ('ALFKI', 'ANATR') AS `Value` FROM `Customers` AS `c` -ORDER BY `c`.`CustomerID`"); +ORDER BY `c`.`CustomerID` +"""); } public override async Task Select_bitwise_or_multiple(bool async) { await base.Select_bitwise_or_multiple(async); - AssertSql( - @"SELECT `c`.`CustomerID`, ((`c`.`CustomerID` = 'ALFKI') | (`c`.`CustomerID` = 'ANATR')) | (`c`.`CustomerID` = 'ANTON') AS `Value` + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`CustomerID` IN ('ALFKI', 'ANATR', 'ANTON') AS `Value` FROM `Customers` AS `c` -ORDER BY `c`.`CustomerID`"); +ORDER BY `c`.`CustomerID` +"""); } public override async Task Select_bitwise_and(bool async) { await base.Select_bitwise_and(async); - AssertSql( - @"SELECT `c`.`CustomerID`, (`c`.`CustomerID` = 'ALFKI') & (`c`.`CustomerID` = 'ANATR') AS `Value` + AssertSql( +""" +SELECT `c`.`CustomerID`, FALSE AS `Value` FROM `Customers` AS `c` -ORDER BY `c`.`CustomerID`"); +ORDER BY `c`.`CustomerID` +"""); } public override async Task Select_bitwise_and_or(bool async) { await base.Select_bitwise_and_or(async); - AssertSql( - @"SELECT `c`.`CustomerID`, ((`c`.`CustomerID` = 'ALFKI') & (`c`.`CustomerID` = 'ANATR')) | (`c`.`CustomerID` = 'ANTON') AS `Value` + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`CustomerID` = 'ANTON' AS `Value` FROM `Customers` AS `c` -ORDER BY `c`.`CustomerID`"); +ORDER BY `c`.`CustomerID` +"""); } public override async Task Where_bitwise_or_with_logical_or(bool async) { await base.Where_bitwise_or_with_logical_or(async); - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` -WHERE ((`c`.`CustomerID` = 'ALFKI') | (`c`.`CustomerID` = 'ANATR')) OR (`c`.`CustomerID` = 'ANTON')"); +WHERE `c`.`CustomerID` IN ('ALFKI', 'ANATR', 'ANTON') +"""); } public override async Task Where_bitwise_and_with_logical_and(bool async) { await base.Where_bitwise_and_with_logical_and(async); - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` -WHERE ((`c`.`CustomerID` = 'ALFKI') & (`c`.`CustomerID` = 'ANATR')) AND (`c`.`CustomerID` = 'ANTON')"); +WHERE FALSE +"""); } public override async Task Where_bitwise_or_with_logical_and(bool async) { await base.Where_bitwise_or_with_logical_and(async); - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` -WHERE ((`c`.`CustomerID` = 'ALFKI') | (`c`.`CustomerID` = 'ANATR')) AND (`c`.`Country` = 'Germany')"); +WHERE `c`.`CustomerID` IN ('ALFKI', 'ANATR') AND (`c`.`Country` = 'Germany') +"""); } public override async Task Where_bitwise_and_with_logical_or(bool async) { await base.Where_bitwise_and_with_logical_or(async); - AssertSql( - @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` FROM `Customers` AS `c` -WHERE ((`c`.`CustomerID` = 'ALFKI') & (`c`.`CustomerID` = 'ANATR')) OR (`c`.`CustomerID` = 'ANTON')"); +WHERE `c`.`CustomerID` = 'ANTON' +"""); } public override async Task Where_bitwise_binary_not(bool async) @@ -130,9 +143,11 @@ public override async Task Where_bitwise_binary_and(bool async) await base.Where_bitwise_binary_and(async); AssertSql( - @"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`OrderID` & 10248) = 10248"); +WHERE CAST(`o`.`OrderID` & 10248 AS signed) = 10248 +"""); } public override async Task Where_bitwise_binary_or(bool async) @@ -140,29 +155,35 @@ public override async Task Where_bitwise_binary_or(bool async) await base.Where_bitwise_binary_or(async); AssertSql( - @"SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` +""" +SELECT `o`.`OrderID`, `o`.`CustomerID`, `o`.`EmployeeID`, `o`.`OrderDate` FROM `Orders` AS `o` -WHERE (`o`.`OrderID` | 10248) = 10248"); +WHERE CAST(`o`.`OrderID` | 10248 AS signed) = 10248 +"""); } public override async Task Select_bitwise_or_with_logical_or(bool async) { await base.Select_bitwise_or_with_logical_or(async); - AssertSql( - @"SELECT `c`.`CustomerID`, ((`c`.`CustomerID` = 'ALFKI') | (`c`.`CustomerID` = 'ANATR')) OR (`c`.`CustomerID` = 'ANTON') AS `Value` + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`CustomerID` IN ('ALFKI', 'ANATR', 'ANTON') AS `Value` FROM `Customers` AS `c` -ORDER BY `c`.`CustomerID`"); +ORDER BY `c`.`CustomerID` +"""); } public override async Task Select_bitwise_and_with_logical_and(bool async) { await base.Select_bitwise_and_with_logical_and(async); - AssertSql( - @"SELECT `c`.`CustomerID`, ((`c`.`CustomerID` = 'ALFKI') & (`c`.`CustomerID` = 'ANATR')) AND (`c`.`CustomerID` = 'ANTON') AS `Value` + AssertSql( +""" +SELECT `c`.`CustomerID`, FALSE AS `Value` FROM `Customers` AS `c` -ORDER BY `c`.`CustomerID`"); +ORDER BY `c`.`CustomerID` +"""); } [ConditionalTheory] diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindQueryMySqlFixture.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindQueryMySqlFixture.cs index 3cf738ece..f28fe556e 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindQueryMySqlFixture.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindQueryMySqlFixture.cs @@ -10,7 +10,7 @@ namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.Query { public class NorthwindQueryMySqlFixture : NorthwindQueryRelationalFixture - where TModelCustomizer : IModelCustomizer, new() + where TModelCustomizer : ITestModelCustomizer, new() { protected override ITestStoreFactory TestStoreFactory => MySqlNorthwindTestStoreFactory.Instance; protected override Type ContextType => typeof(NorthwindMySqlContext); diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindSelectQueryMySqlTest.MySql.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindSelectQueryMySqlTest.MySql.cs index 3b12c1b10..7b97a7a07 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindSelectQueryMySqlTest.MySql.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindSelectQueryMySqlTest.MySql.cs @@ -33,28 +33,26 @@ await AssertQuery( ss => ss.Set() .Where(o => o.CustomerID == "ALFKI" && o.OrderDate != null) - .GroupBy(o => new {o.CustomerID, o.OrderDate.Value.Year}) - .Select(g => new {g.Key.Year, Count = g.Count()}) + .GroupBy(o => new {o.CustomerID, o.OrderDate.Value.Date}) + .Select(g => new {g.Key.Date.Year, Count = g.Count()}) .Where(k => k.Year == 1995) .OrderBy(k => k.Year), assertOrder: true, assertEmpty: true); // TODO: Use a linq query that does not return an empty result. - AssertSql( -""" -SELECT `o3`.`Year`, `o3`.`Count` + AssertSql( + @"SELECT `o1`.`Year`, `o1`.`Count` FROM ( - SELECT `o0`.`Year`, COUNT(*) AS `Count`, `o0`.`CustomerID`, `o0`.`Year` = 1995 AS `c` + SELECT EXTRACT(year FROM `o0`.`Date`) AS `Year`, COUNT(*) AS `Count`, (EXTRACT(year FROM `o0`.`Date`) = 1995) AND EXTRACT(year FROM `o0`.`Date`) IS NOT NULL AS `c` FROM ( - SELECT `o`.`CustomerID`, EXTRACT(year FROM `o`.`OrderDate`) AS `Year` + SELECT `o`.`CustomerID`, CONVERT(`o`.`OrderDate`, date) AS `Date` FROM `Orders` AS `o` WHERE (`o`.`CustomerID` = 'ALFKI') AND `o`.`OrderDate` IS NOT NULL ) AS `o0` - GROUP BY `o0`.`CustomerID`, `o0`.`Year`, `c` + GROUP BY `o0`.`CustomerID`, `o0`.`Date`, `c` HAVING `c` -) AS `o3` -ORDER BY `o3`.`Year` -"""); +) AS `o1` +ORDER BY `o1`.`Year`"); } [ConditionalTheory] @@ -80,9 +78,9 @@ await AssertQueryScalar( AssertSql( """ -SELECT `o7`.`Year` +SELECT `o3`.`Year` FROM ( - SELECT `o0`.`Year`, `o0`.`CustomerID`, `o0`.`Year` = 1995 AS `c` + SELECT `o0`.`Year`, (`o0`.`Year` = 1995) AND `o0`.`Year` IS NOT NULL AS `c` FROM ( SELECT `o`.`CustomerID`, EXTRACT(year FROM `o`.`OrderDate`) AS `Year` FROM `Orders` AS `o` @@ -90,7 +88,7 @@ await AssertQueryScalar( ) AS `o0` GROUP BY `o0`.`CustomerID`, `o0`.`Year`, `c` HAVING `c` -) AS `o7` +) AS `o3` UNION ALL SELECT `o2`.`Key` AS `Year` FROM ( diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindSelectQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindSelectQueryMySqlTest.cs index ec6db87b8..e7c067f2e 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindSelectQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindSelectQueryMySqlTest.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Diagnostics; @@ -26,9 +26,6 @@ public NorthwindSelectQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - [ConditionalTheory] public override async Task Select_datetime_year_component(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindSetOperationsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindSetOperationsQueryMySqlTest.cs index 50ea0c948..610bd82b5 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindSetOperationsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindSetOperationsQueryMySqlTest.cs @@ -22,9 +22,6 @@ public NorthwindSetOperationsQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - public override async Task Client_eval_Union_FirstOrDefault(bool async) { // Client evaluation in projection. Issue #16243. diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindSqlQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindSqlQueryMySqlTest.cs index 0166febd2..63141002e 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindSqlQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindSqlQueryMySqlTest.cs @@ -3,6 +3,7 @@ using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestUtilities; using MySqlConnector; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Xunit; using Xunit.Abstractions; @@ -18,7 +19,7 @@ public NorthwindSqlQueryMySqlTest(NorthwindQueryMySqlFixture TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task SqlQueryRaw_over_int(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindStringComparisonFunctionsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindStringComparisonFunctionsQueryMySqlTest.cs new file mode 100644 index 000000000..ad16ef30d --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindStringComparisonFunctionsQueryMySqlTest.cs @@ -0,0 +1,769 @@ +using System; +using System.Linq; +using System.Threading.Tasks; +using JetBrains.Annotations; +using Microsoft.EntityFrameworkCore.Query; +using Microsoft.EntityFrameworkCore.TestModels.Northwind; +using Microsoft.EntityFrameworkCore.TestUtilities; +using Xunit; +using Xunit.Abstractions; + +namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.Query +{ + public class NorthwindStringComparisonFunctionsQueryMySqlTest : QueryTestBase> + { + public NorthwindStringComparisonFunctionsQueryMySqlTest( + [NotNull] CaseSensitiveWithStringComparisonNorthwindQueryMySqlFixture fixture, + ITestOutputHelper testOutputHelper) + : base(fixture) + { + ClearLog(); + //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); + } + + [ConditionalTheory] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.Ordinal, 0, false)] + [InlineData(StringComparison.Ordinal, 0, true)] + [InlineData(StringComparison.CurrentCulture, 0, false)] + [InlineData(StringComparison.CurrentCulture, 0, true)] + [InlineData(StringComparison.InvariantCulture, 0, false)] + [InlineData(StringComparison.InvariantCulture, 0, true)] + public async Task StringEquals_with_comparison_parameter(StringComparison comparison, int expected, bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Equals("anton", comparison)), + assertEmpty: expected == 0); + + // When the comparison parameter is not a constant, we have to use a case + // statement + AssertSql( + $@"@__comparison_0='{comparison:D}' + +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE CASE + WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin + ELSE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin +END"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEquals_ordinal(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.Ordinal)), + assertEmpty: true); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEquals_invariant(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.CurrentCulture)), + assertEmpty: true); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEquals_current(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.InvariantCulture)), + assertEmpty: true); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEquals_ordinal_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.OrdinalIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEquals_current_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.CurrentCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEquals_invariant_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Equals("anton", StringComparison.InvariantCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.Ordinal, 0, false)] + [InlineData(StringComparison.Ordinal, 0, true)] + [InlineData(StringComparison.CurrentCulture, 0, false)] + [InlineData(StringComparison.CurrentCulture, 0, true)] + [InlineData(StringComparison.InvariantCulture, 0, false)] + [InlineData(StringComparison.InvariantCulture, 0, true)] + public async Task StaticStringEquals_with_comparison(StringComparison comparison, int expected, bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", comparison)), + assertEmpty: expected == 0); + + // When the comparison parameter is not a constant, we have to use a case + // statement + AssertSql( + $@"@__comparison_0='{comparison:D}' + +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE CASE + WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin + ELSE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin +END"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StaticStringEquals_ordinal(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.Ordinal)), + assertEmpty: true); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StaticStringEquals_invariant(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.CurrentCulture)), + assertEmpty: true); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StaticStringEquals_current(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.InvariantCulture)), + assertEmpty: true); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` = CONVERT('anton' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StaticStringEquals_ordinal_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.OrdinalIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StaticStringEquals_current_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.CurrentCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StaticStringEquals_invariant_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => string.Equals(c.CustomerID, "anton", StringComparison.InvariantCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) = CONVERT(LCASE('anton') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.Ordinal, 0, false)] + [InlineData(StringComparison.Ordinal, 0, true)] + [InlineData(StringComparison.CurrentCulture, 0, false)] + [InlineData(StringComparison.CurrentCulture, 0, true)] + [InlineData(StringComparison.InvariantCulture, 0, false)] + [InlineData(StringComparison.InvariantCulture, 0, true)] + public async Task StringContains_with_comparison(StringComparison comparison, int expected, bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Contains("nto", comparison)), + assertEmpty: expected == 0); + + // When the comparison parameter is not a constant, we have to use a case + // statement + AssertSql( + $@"@__comparison_0='{comparison:D}' + +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE CASE + WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` LIKE CONVERT('%nto%' USING utf8mb4) COLLATE utf8mb4_bin + ELSE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nto%') USING utf8mb4) COLLATE utf8mb4_bin +END"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringContains_ordinal(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.Ordinal)), + assertEmpty: true); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE CONVERT('%nto%' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringContains_invariant(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.CurrentCulture)), + assertEmpty: true); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE CONVERT('%nto%' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringContains_current(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.InvariantCulture)), + assertEmpty: true); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE CONVERT('%nto%' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringContains_ordinal_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.OrdinalIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nto%') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringContains_current_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.CurrentCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nto%') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringContains_invariant_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.Contains("nto", StringComparison.InvariantCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nto%') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.Ordinal, 0, false)] + [InlineData(StringComparison.Ordinal, 0, true)] + [InlineData(StringComparison.CurrentCulture, 0, false)] + [InlineData(StringComparison.CurrentCulture, 0, true)] + [InlineData(StringComparison.InvariantCulture, 0, false)] + [InlineData(StringComparison.InvariantCulture, 0, true)] + public async Task StringStartsWith_with_comparison(StringComparison comparison, int expected, bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", comparison)), + assertEmpty: expected == 0); + + // When the comparison parameter is not a constant, we have to use a case + // statement + AssertSql( + $@"@__comparison_0='{comparison:D}' + +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE CASE + WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` LIKE CONVERT('anto' USING utf8mb4) COLLATE utf8mb4_bin + ELSE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('anto%') USING utf8mb4) COLLATE utf8mb4_bin +END"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringStartsWith_ordinal(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.Ordinal)), + assertEmpty: true); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE CONVERT('anto%' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringStartsWith_invariant(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.CurrentCulture)), + assertEmpty: true); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE CONVERT('anto%' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringStartsWith_current(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.InvariantCulture)), + assertEmpty: true); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE CONVERT('anto%' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringStartsWith_ordinal_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.OrdinalIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(LCASE(`c`.`CustomerID`)) LIKE CONVERT(LCASE('anto%') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringStartsWith_current_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.CurrentCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(LCASE(`c`.`CustomerID`)) LIKE CONVERT(LCASE('anto%') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringStartsWith_invariant_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.StartsWith("anto", StringComparison.InvariantCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(LCASE(`c`.`CustomerID`)) LIKE CONVERT(LCASE('anto%') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.Ordinal, 0, false)] + [InlineData(StringComparison.Ordinal, 0, true)] + [InlineData(StringComparison.CurrentCulture, 0, false)] + [InlineData(StringComparison.CurrentCulture, 0, true)] + [InlineData(StringComparison.InvariantCulture, 0, false)] + [InlineData(StringComparison.InvariantCulture, 0, true)] + public async Task StringEndsWith_with_comparison(StringComparison comparison, int expected, bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", comparison)), + assertEmpty: expected == 0); + + AssertSql( + $@"@__comparison_0='{comparison:D}' + +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE CASE + WHEN @__comparison_0 IN (4, 0, 2) THEN `c`.`CustomerID` LIKE CONVERT('%nton' USING utf8mb4) COLLATE utf8mb4_bin + ELSE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nton') USING utf8mb4) COLLATE utf8mb4_bin +END"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEndsWith_ordinal(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.Ordinal)), + assertEmpty: true); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE CONVERT('%nton' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEndsWith_invariant(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.CurrentCulture)), + assertEmpty: true); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE CONVERT('%nton' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEndsWith_current(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.InvariantCulture)), + assertEmpty: true); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE `c`.`CustomerID` LIKE CONVERT('%nton' USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEndsWith_ordinal_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.OrdinalIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nton') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEndsWith_current_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.CurrentCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nton') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringEndsWith_invariant_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.EndsWith("nton", StringComparison.InvariantCultureIgnoreCase))); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE LCASE(`c`.`CustomerID`) LIKE CONVERT(LCASE('%nton') USING utf8mb4) COLLATE utf8mb4_bin"); + } + + [ConditionalTheory] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, false)] + [InlineData(StringComparison.OrdinalIgnoreCase, 1, true)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.CurrentCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, false)] + [InlineData(StringComparison.InvariantCultureIgnoreCase, 1, true)] + [InlineData(StringComparison.Ordinal, 0, false)] + [InlineData(StringComparison.Ordinal, 0, true)] + [InlineData(StringComparison.CurrentCulture, 0, false)] + [InlineData(StringComparison.CurrentCulture, 0, true)] + [InlineData(StringComparison.InvariantCulture, 0, false)] + [InlineData(StringComparison.InvariantCulture, 0, true)] + public async Task StringIndexOf_with_comparison(StringComparison comparison, int expected, bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", comparison) == 1), + assertEmpty: expected == 0); + + // When the comparison parameter is not a constant, we have to use a case + // statement + AssertSql($"@__comparison_0='{comparison:D}'" + @" + +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE CASE + WHEN @__comparison_0 IN (4, 0, 2) THEN LOCATE(CONVERT('nt' USING utf8mb4) COLLATE utf8mb4_bin, `c`.`CustomerID`) - 1 + ELSE LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`)) - 1 +END = 1"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringIndexOf_with_constant_start_index(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", 0, StringComparison.OrdinalIgnoreCase) == 1)); + + AssertSql( + @"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`), 1) - 1) = 1"); + } + + [ConditionalTheory] + [InlineData(0, 1, false)] + [InlineData(2, 0, false)] + [InlineData(0, 1, true)] + [InlineData(2, 0, true)] + public async Task StringIndexOf_with_parameter_start_index(int startIndex, int expected, bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", startIndex, StringComparison.OrdinalIgnoreCase) == 1), + assertEmpty: expected == 0); + + AssertSql( + @$"@__startIndex_0='{startIndex}' + +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`), @__startIndex_0 + 1) - 1) = 1"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringIndexOf_ordinal(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.Ordinal) == 1), + assertEmpty: true); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE (LOCATE(CONVERT('nt' USING utf8mb4) COLLATE utf8mb4_bin, `c`.`CustomerID`) - 1) = 1"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringIndexOf_invariant(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.InvariantCulture) == 1), + assertEmpty: true); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE (LOCATE(CONVERT('nt' USING utf8mb4) COLLATE utf8mb4_bin, `c`.`CustomerID`) - 1) = 1"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringIndexOf_current(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.CurrentCulture) == 1), + assertEmpty: true); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE (LOCATE(CONVERT('nt' USING utf8mb4) COLLATE utf8mb4_bin, `c`.`CustomerID`) - 1) = 1"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringIndexOf_ordinal_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.OrdinalIgnoreCase) == 1)); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`)) - 1) = 1"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringIndexOf_current_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.CurrentCultureIgnoreCase) == 1)); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`)) - 1) = 1"); + } + + [ConditionalTheory] + [MemberData(nameof(IsAsyncData))] + public async Task StringIndexOf_invariant_ignore_case(bool async) + { + await AssertQuery( + async, + ss => ss.Set().Where(c => c.CustomerID.IndexOf("nt", StringComparison.InvariantCultureIgnoreCase) == 1)); + + AssertSql(@"SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE (LOCATE(CONVERT(LCASE('nt') USING utf8mb4) COLLATE utf8mb4_bin, LCASE(`c`.`CustomerID`)) - 1) = 1"); + } + + private void AssertSql(params string[] expected) + => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); + + private void ClearLog() + => Fixture.TestSqlLoggerFactory.Clear(); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Query/NorthwindWhereQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/NorthwindWhereQueryMySqlTest.cs index 083567533..ce5c1c9ac 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/NorthwindWhereQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/NorthwindWhereQueryMySqlTest.cs @@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestModels.Northwind; using Microsoft.EntityFrameworkCore.TestUtilities; +using Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes; using Xunit; using Xunit.Abstractions; @@ -22,9 +23,6 @@ public NorthwindWhereQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - [ConditionalTheory] public override async Task Where_datetime_now(bool async) { @@ -379,7 +377,7 @@ public virtual async Task Where_string_concat_method_comparison_object_3(bool as await AssertQuery( async, - ss => ss.Set().Where(c => string.Concat(i, j, k, c.CustomerID) == c.CompanyName).Select(c => c.CustomerID), + ss => ss.Set().Where(c => string.Concat(new[] { i, j, k, c.CustomerID }) == c.CompanyName).Select(c => c.CustomerID), assertEmpty: true); AssertSql( @@ -405,7 +403,7 @@ public virtual async Task Where_string_concat_method_comparison_params_string_ar await AssertQuery( async, - ss => ss.Set().Where(c => string.Concat(i, j, k, m, c.CustomerID) == c.CompanyName).Select(c => c.CustomerID), + ss => ss.Set().Where(c => string.Concat(new[] { i, j, k, m, c.CustomerID }) == c.CompanyName).Select(c => c.CustomerID), assertEmpty: true); AssertSql( @@ -470,7 +468,7 @@ public virtual async Task Where_string_concat_method_comparison_params_object_ar await AssertQuery( async, - ss => ss.Set().Where(c => string.Concat(i, j, k, m, c.CustomerID) == c.CompanyName).Select(c => c.CustomerID), + ss => ss.Set().Where(c => string.Concat(new[] { i, j, k, m, c.CustomerID }) == c.CompanyName).Select(c => c.CustomerID), assertEmpty: true); AssertSql( @@ -602,10 +600,99 @@ await AssertQuery( public override async Task Where_bitwise_xor(bool async) { - // Cannot eval 'where (([c].CustomerID == \"ALFKI\") ^ True)'. Issue #16645. - await AssertTranslationFailed(() => base.Where_bitwise_xor(async)); + await base.Where_bitwise_xor(async); - AssertSql(); + AssertSql( +""" +SELECT `c`.`CustomerID`, `c`.`Address`, `c`.`City`, `c`.`CompanyName`, `c`.`ContactName`, `c`.`ContactTitle`, `c`.`Country`, `c`.`Fax`, `c`.`Phone`, `c`.`PostalCode`, `c`.`Region` +FROM `Customers` AS `c` +WHERE (`c`.`CustomerID` = 'ALFKI') ^ TRUE +"""); + } + + // TODO: 9.0 + [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = +""" +There is some strange collation behavior with MariaDB 11.4.x and this test (seems fixed in 11.5). +The default utf8mb4 collation was changed in 11.4.2 from utf8mb4_general_ci to utf8mb4_uca1400_ai_ci. +We changed MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation accordingly. +If we run the this test against a Ubuntu hosted MariaDB, the test always works. +If we run the this test against a Windows hosted MariaDB, the test fails only on the first execution (when the database does not preexist). But it works on all consecutive runs. +If we change MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation to use the new default collations only from 11.5.0, the Ubuntu/Windows behavior flips to Windows always working and Ubuntu not successfully executing the test on the first run. +The error is: + MySqlConnector.MySqlException : Illegal mix of collations (utf8mb4_bin,NONE) and (utf8mb4_general_ci,IMPLICIT) for operation '=' +""")] + public override Task Where_concat_string_int_comparison1(bool async) + { + return base.Where_concat_string_int_comparison1(async); + } + + // TODO: 9.0 + [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = +""" +There is some strange collation behavior with MariaDB 11.4.x and this test (seems fixed in 11.5). +The default utf8mb4 collation was changed in 11.4.2 from utf8mb4_general_ci to utf8mb4_uca1400_ai_ci. +We changed MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation accordingly. +If we run the this test against a Ubuntu hosted MariaDB, the test always works. +If we run the this test against a Windows hosted MariaDB, the test fails only on the first execution (when the database does not preexist). But it works on all consecutive runs. +If we change MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation to use the new default collations only from 11.5.0, the Ubuntu/Windows behavior flips to Windows always working and Ubuntu not successfully executing the test on the first run. +The error is: + MySqlConnector.MySqlException : Illegal mix of collations (utf8mb4_bin,NONE) and (utf8mb4_general_ci,IMPLICIT) for operation '=' +""")] + public override Task Where_concat_string_int_comparison2(bool async) + { + return base.Where_concat_string_int_comparison2(async); + } + + // TODO: 9.0 + [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = +""" +There is some strange collation behavior with MariaDB 11.4.x and this test (seems fixed in 11.5). +The default utf8mb4 collation was changed in 11.4.2 from utf8mb4_general_ci to utf8mb4_uca1400_ai_ci. +We changed MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation accordingly. +If we run the this test against a Ubuntu hosted MariaDB, the test always works. +If we run the this test against a Windows hosted MariaDB, the test fails only on the first execution (when the database does not preexist). But it works on all consecutive runs. +If we change MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation to use the new default collations only from 11.5.0, the Ubuntu/Windows behavior flips to Windows always working and Ubuntu not successfully executing the test on the first run. +The error is: + MySqlConnector.MySqlException : Illegal mix of collations (utf8mb4_bin,NONE) and (utf8mb4_general_ci,IMPLICIT) for operation '=' +""")] + public override Task Where_concat_string_int_comparison3(bool async) + { + return base.Where_concat_string_int_comparison3(async); + } + + // TODO: 9.0 + [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = +""" +There is some strange collation behavior with MariaDB 11.4.x and this test (seems fixed in 11.5). +The default utf8mb4 collation was changed in 11.4.2 from utf8mb4_general_ci to utf8mb4_uca1400_ai_ci. +We changed MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation accordingly. +If we run the this test against a Ubuntu hosted MariaDB, the test always works. +If we run the this test against a Windows hosted MariaDB, the test fails only on the first execution (when the database does not preexist). But it works on all consecutive runs. +If we change MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation to use the new default collations only from 11.5.0, the Ubuntu/Windows behavior flips to Windows always working and Ubuntu not successfully executing the test on the first run. +The error is: + MySqlConnector.MySqlException : Illegal mix of collations (utf8mb4_bin,NONE) and (utf8mb4_general_ci,IMPLICIT) for operation '=' +""")] + public override Task Where_concat_string_int_comparison4(bool async) + { + return base.Where_concat_string_int_comparison4(async); + } + + // TODO: 9.0 + [SupportedServerVersionBetweenCondition("11.4.2-mariadb", "11.5.0-mariadb", Invert = true, Skip = +""" +There is some strange collation behavior with MariaDB 11.4.x and this test (seems fixed in 11.5). +The default utf8mb4 collation was changed in 11.4.2 from utf8mb4_general_ci to utf8mb4_uca1400_ai_ci. +We changed MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation accordingly. +If we run the this test against a Ubuntu hosted MariaDB, the test always works. +If we run the this test against a Windows hosted MariaDB, the test fails only on the first execution (when the database does not preexist). But it works on all consecutive runs. +If we change MariaDbServerVersion.DefaultUtf8CiCollation and MariaDbServerVersion.DefaultUtf8CsCollation to use the new default collations only from 11.5.0, the Ubuntu/Windows behavior flips to Windows always working and Ubuntu not successfully executing the test on the first run. +The error is: + MySqlConnector.MySqlException : Illegal mix of collations (utf8mb4_bin,NONE) and (utf8mb4_uca1400_ai_ci,COERCIBLE) for operation '=' +""")] + public override Task Using_same_parameter_twice_in_query_generates_one_sql_parameter(bool async) + { + return base.Using_same_parameter_twice_in_query_generates_one_sql_parameter(async); } public override async Task Where_compare_constructed_equal(bool async) diff --git a/test/EFCore.MySql.FunctionalTests/Query/OperatorsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/OperatorsQueryMySqlTest.cs index 93f2ae26d..c182b2838 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/OperatorsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/OperatorsQueryMySqlTest.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestModels.Operators; @@ -20,21 +20,46 @@ public override async Task Bitwise_and_on_expression_with_like_and_null_check_be { await base.Bitwise_and_on_expression_with_like_and_null_check_being_compared_to_false(); - AssertSql(""); + AssertSql( +""" +SELECT `o`.`Value` AS `Value1`, `o0`.`Value` AS `Value2`, `o1`.`Value` AS `Value3` +FROM `OperatorEntityString` AS `o` +CROSS JOIN `OperatorEntityString` AS `o0` +CROSS JOIN `OperatorEntityBool` AS `o1` +WHERE (((`o0`.`Value` LIKE 'B') AND `o0`.`Value` IS NOT NULL) OR `o1`.`Value`) AND `o`.`Value` IS NOT NULL +ORDER BY `o`.`Id`, `o0`.`Id`, `o1`.`Id` +"""); } public override async Task Complex_predicate_with_bitwise_and_modulo_and_negation() { await base.Complex_predicate_with_bitwise_and_modulo_and_negation(); - AssertSql(""); + AssertSql( +""" +SELECT `o`.`Value` AS `Value0`, `o0`.`Value` AS `Value1`, `o1`.`Value` AS `Value2`, `o2`.`Value` AS `Value3` +FROM `OperatorEntityLong` AS `o` +CROSS JOIN `OperatorEntityLong` AS `o0` +CROSS JOIN `OperatorEntityLong` AS `o1` +CROSS JOIN `OperatorEntityLong` AS `o2` +WHERE CAST(((`o0`.`Value` % 2) / `o`.`Value`) & ((CAST(`o2`.`Value` | `o1`.`Value` AS signed) - `o`.`Value`) - (`o1`.`Value` * `o1`.`Value`)) AS signed) >= (((`o0`.`Value` / CAST(~`o2`.`Value` AS signed)) % 2) % (CAST(~`o`.`Value` AS signed) + 1)) +ORDER BY `o`.`Id`, `o0`.`Id`, `o1`.`Id`, `o2`.`Id` +"""); } public override async Task Complex_predicate_with_bitwise_and_arithmetic_operations() { await base.Complex_predicate_with_bitwise_and_arithmetic_operations(); - AssertSql(""); + AssertSql( +""" +SELECT `o`.`Value` AS `Value0`, `o0`.`Value` AS `Value1`, `o1`.`Value` AS `Value2` +FROM `OperatorEntityInt` AS `o` +CROSS JOIN `OperatorEntityInt` AS `o0` +CROSS JOIN `OperatorEntityBool` AS `o1` +WHERE ((CAST(CAST(`o0`.`Value` & (`o`.`Value` + `o`.`Value`) AS signed) & `o`.`Value` AS signed) / 1) > CAST(`o0`.`Value` & 10 AS signed)) AND `o1`.`Value` +ORDER BY `o`.`Id`, `o0`.`Id`, `o1`.`Id` +"""); } public override async Task Or_on_two_nested_binaries_and_another_simple_comparison() @@ -49,7 +74,7 @@ CROSS JOIN `OperatorEntityString` AS `o0` CROSS JOIN `OperatorEntityString` AS `o1` CROSS JOIN `OperatorEntityString` AS `o2` CROSS JOIN `OperatorEntityInt` AS `o3` -WHERE ((((`o`.`Value` = 'A') AND `o`.`Value` IS NOT NULL) AND ((`o0`.`Value` = 'A') AND `o0`.`Value` IS NOT NULL)) | (((`o1`.`Value` = 'B') AND `o1`.`Value` IS NOT NULL) AND ((`o2`.`Value` = 'B') AND `o2`.`Value` IS NOT NULL))) AND (`o3`.`Value` = 2) +WHERE (((`o`.`Value` = 'A') AND (`o0`.`Value` = 'A')) OR ((`o1`.`Value` = 'B') AND (`o2`.`Value` = 'B'))) AND (`o3`.`Value` = 2) ORDER BY `o`.`Id`, `o0`.`Id`, `o1`.`Id`, `o2`.`Id`, `o3`.`Id` """); } @@ -120,7 +145,7 @@ public override async Task Negate_on_like_expression(bool async) public override Task Concat_and_json_scalar(bool async) => Assert.ThrowsAsync(() => base.Concat_and_json_scalar(async)); - protected override void Seed(OperatorsContext ctx) + protected override async Task Seed(OperatorsContext ctx) { ctx.Set().AddRange(ExpectedData.OperatorEntitiesString); ctx.Set().AddRange(ExpectedData.OperatorEntitiesInt); @@ -130,6 +155,6 @@ protected override void Seed(OperatorsContext ctx) ctx.Set().AddRange(ExpectedData.OperatorEntitiesNullableBool); // ctx.Set().AddRange(ExpectedData.OperatorEntitiesDateTimeOffset); - ctx.SaveChanges(); + await ctx.SaveChangesAsync(); } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/OwnedEntityQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/OwnedEntityQueryMySqlTest.cs index 28c9b8fe7..1f85720d7 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/OwnedEntityQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/OwnedEntityQueryMySqlTest.cs @@ -69,7 +69,7 @@ public override async Task Owned_collection_basic_split_query(bool async) // Use base implementation once https://github.com/dotnet/efcore/pull/32509#issuecomment-1948812777 is fixed. public override async Task Projecting_correlated_collection_property_for_owned_entity(bool async) { - var contextFactory = await InitializeAsync(seed: c => c.Seed()); + var contextFactory = await InitializeAsync(seed: c => c.SeedAsync()); using var context = contextFactory.CreateContext(); var query = context.Warehouses.Select( @@ -90,62 +90,11 @@ public override async Task Projecting_correlated_collection_property_for_owned_e Assert.True(new[] { "US", "CA" }.SequenceEqual(warehouseModel.DestinationCountryCodes)); } - // The `Context18582` in `OwnedEntityQueryTestBase.cs` is private (as many other context classes there), so we cannot override any - // tests that use it without duplicating the the whole context class, even though we don't need to change the class at all. - private class Context18582(DbContextOptions options) : DbContext(options) - { - public DbSet Warehouses { get; set; } - - public void Seed() - { - Add( - new Warehouse - { - WarehouseCode = "W001", - DestinationCountries = - { - new WarehouseDestinationCountry { Id = "1", CountryCode = "US" }, - new WarehouseDestinationCountry { Id = "2", CountryCode = "CA" } - } - }); - - SaveChanges(); - } - - protected override void OnModelCreating(ModelBuilder modelBuilder) - => modelBuilder.Entity() - .OwnsMany(x => x.DestinationCountries) - .WithOwner() - .HasForeignKey(x => x.WarehouseCode) - .HasPrincipalKey(x => x.WarehouseCode); - - public class Warehouse - { - public int Id { get; set; } - public string WarehouseCode { get; set; } - public ICollection DestinationCountries { get; set; } = new HashSet(); - } - - public class WarehouseDestinationCountry - { - public string Id { get; set; } - public string WarehouseCode { get; set; } - public string CountryCode { get; set; } - } - - public class WarehouseModel - { - public string WarehouseCode { get; set; } - - public ICollection DestinationCountryCodes { get; set; } - } - } - // Use base implementation once https://github.com/dotnet/efcore/pull/32509#issuecomment-1948812777 is fixed and the base // implementation has been fixed to use a deterministic order. public override async Task Correlated_subquery_with_owned_navigation_being_compared_to_null_works() { - var contextFactory = await InitializeAsync(seed: c => c.Seed()); + var contextFactory = await InitializeAsync(seed: c => c.SeedAsync()); using (var context = contextFactory.CreateContext()) { @@ -186,47 +135,5 @@ public override async Task Correlated_subquery_with_owned_navigation_being_compa ORDER BY `p`.`Id` """); } - - // The `Context13157` in `OwnedEntityQueryTestBase.cs` is private (as many other context classes there), so we cannot override any - // tests that use it without duplicating the the whole context class, even though we don't need to change the class at all. - private class Context13157(DbContextOptions options) : DbContext(options) - { - public virtual DbSet Partners { get; set; } - - protected override void OnModelCreating(ModelBuilder modelBuilder) - => modelBuilder.Entity
().OwnsOne(x => x.Turnovers); - - public void Seed() - { - AddRange( - new Partner - { - Addresses = new List
- { - new() { Turnovers = new AddressTurnovers { AmountIn = 10 } }, new() { Turnovers = null }, - } - } - ); - - SaveChanges(); - } - - public class Partner - { - public int Id { get; set; } - public ICollection
Addresses { get; set; } - } - - public class Address - { - public int Id { get; set; } - public AddressTurnovers Turnovers { get; set; } - } - - public class AddressTurnovers - { - public int AmountIn { get; set; } - } - } } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/OwnedQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/OwnedQueryMySqlTest.cs index dc3f32ac9..3d385f422 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/OwnedQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/OwnedQueryMySqlTest.cs @@ -1,6 +1,9 @@ -using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; +using System.Threading.Tasks; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestUtilities; +using Pomelo.EntityFrameworkCore.MySql.Infrastructure; +using Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes; using Xunit.Abstractions; namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.Query @@ -13,8 +16,17 @@ public OwnedQueryMySqlTest(OwnedQueryMySqlFixture fixture, ITestOutputHelper tes //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; + [SupportedServerVersionCondition(nameof(ServerVersionSupport.WhereSubqueryReferencesOuterQuery))] + public override Task Union_over_owned_collection(bool async) + { + return base.Union_over_owned_collection(async); + } + + [SupportedServerVersionCondition(nameof(ServerVersionSupport.WhereSubqueryReferencesOuterQuery))] + public override Task Distinct_over_owned_collection(bool async) + { + return base.Distinct_over_owned_collection(async); + } public class OwnedQueryMySqlFixture : RelationalOwnedQueryFixture { diff --git a/test/EFCore.MySql.FunctionalTests/Query/PrimitiveCollectionsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/PrimitiveCollectionsQueryMySqlTest.cs index 069631c2d..8f2c4e74a 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/PrimitiveCollectionsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/PrimitiveCollectionsQueryMySqlTest.cs @@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Diagnostics; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestUtilities; +using MySqlConnector; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.Infrastructure; using Pomelo.EntityFrameworkCore.MySql.Tests; @@ -1655,9 +1656,40 @@ END IN ('one', 'two', 'three') """); } - public override async Task Inline_collection_Contains_with_EF_Constant(bool async) + public override async Task Inline_collection_with_single_parameter_element_Contains(bool async) { - await base.Inline_collection_Contains_with_EF_Constant(async); + await base.Inline_collection_with_single_parameter_element_Contains(async); + + AssertSql( +""" +@__i_0='2' + +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE `p`.`Id` = @__i_0 +"""); + } + + public override async Task Inline_collection_with_single_parameter_element_Count(bool async) + { + await base.Inline_collection_with_single_parameter_element_Count(async); + + AssertSql( +""" +@__i_0='2' + +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE ( + SELECT COUNT(*) + FROM (SELECT CAST(@__i_0 AS signed) AS `Value`) AS `v` + WHERE `v`.`Value` > `p`.`Id`) = 1 +"""); + } + + public override async Task Parameter_collection_Contains_with_EF_Constant(bool async) + { + await base.Parameter_collection_Contains_with_EF_Constant(async); AssertSql( """ @@ -1667,6 +1699,40 @@ public override async Task Inline_collection_Contains_with_EF_Constant(bool asyn """); } + public override async Task Parameter_collection_Where_with_EF_Constant_Where_Any(bool async) + { + await base.Parameter_collection_Where_with_EF_Constant_Where_Any(async); + + var rowSql = AppConfig.ServerVersion.Supports.ValuesWithRows ? "ROW" : string.Empty; + + AssertSql( +$""" +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE EXISTS ( + SELECT 1 + FROM (SELECT 2 AS `Value` UNION ALL VALUES {rowSql}(999), {rowSql}(1000)) AS `i` + WHERE `i`.`Value` > 0) +"""); + } + + public override async Task Parameter_collection_Count_with_column_predicate_with_EF_Constant(bool async) + { + await base.Parameter_collection_Count_with_column_predicate_with_EF_Constant(async); + + var rowSql = AppConfig.ServerVersion.Supports.ValuesWithRows ? "ROW" : string.Empty; + + AssertSql( +$""" +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE ( + SELECT COUNT(*) + FROM (SELECT 2 AS `Value` UNION ALL VALUES {rowSql}(999), {rowSql}(1000)) AS `i` + WHERE `i`.`Value` > `p`.`Id`) = 2 +"""); + } + public override async Task Inline_collection_Min_with_two_values(bool async) { await base.Inline_collection_Min_with_two_values(async); @@ -1829,9 +1895,356 @@ LIMIT 1 """); } + public override async Task Project_inline_collection_with_Concat(bool async) + { + await base.Project_inline_collection_with_Concat(async); + + AssertSql(); + } + + public override async Task Column_collection_Where_equality_inline_collection(bool async) + { + await base.Column_collection_Where_equality_inline_collection(async); + + AssertSql(); + } + + public override async Task Inline_collection_List_Contains_with_mixed_value_types(bool async) + { + await base.Inline_collection_List_Contains_with_mixed_value_types(async); + + AssertSql( +""" +@__i_0='11' + +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE `p`.`Int` IN (999, @__i_0, `p`.`Id`, `p`.`Id` + `p`.`Int`) +"""); + } + + public override async Task Inline_collection_List_Min_with_two_values(bool async) + { + await base.Inline_collection_List_Min_with_two_values(async); + + AssertSql( +""" +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE LEAST(30, `p`.`Int`) = 30 +"""); + } + + public override async Task Inline_collection_List_Max_with_two_values(bool async) + { + await base.Inline_collection_List_Max_with_two_values(async); + + AssertSql( +""" +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE GREATEST(30, `p`.`Int`) = 30 +"""); + } + + public override async Task Inline_collection_List_Min_with_three_values(bool async) + { + await base.Inline_collection_List_Min_with_three_values(async); + + AssertSql( +""" +@__i_0='25' + +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE LEAST(30, `p`.`Int`, @__i_0) = 25 +"""); + } + + public override async Task Inline_collection_List_Max_with_three_values(bool async) + { + await base.Inline_collection_List_Max_with_three_values(async); + + AssertSql( +""" +@__i_0='35' + +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE GREATEST(30, `p`.`Int`, @__i_0) = 35 +"""); + } + + public override async Task Inline_collection_of_nullable_value_type_Min(bool async) + { + if (AppConfig.ServerVersion.Supports.FieldReferenceInTableValueConstructor) + { + await base.Inline_collection_of_nullable_value_type_Min(async); + + AssertSql( +""" +@__i_0='25' (Nullable = true) + +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE ( + SELECT MIN(`v`.`Value`) + FROM (SELECT CAST(30 AS signed) AS `Value` UNION ALL VALUES ROW(`p`.`Int`), ROW(@__i_0)) AS `v`) = 25 +"""); + } + else + { + var exception = await Assert.ThrowsAsync(() => base.Inline_collection_of_nullable_value_type_Min(async)); + Assert.True(exception.Message is "Field reference 'p.Int' can't be used in table value constructor" + or "Unknown table 'p' in order clause"); + } + } + + public override async Task Inline_collection_of_nullable_value_type_Max(bool async) + { + if (AppConfig.ServerVersion.Supports.FieldReferenceInTableValueConstructor) + { + await base.Inline_collection_of_nullable_value_type_Max(async); + + AssertSql( +""" +@__i_0='35' (Nullable = true) + +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE ( + SELECT MAX(`v`.`Value`) + FROM (SELECT CAST(30 AS signed) AS `Value` UNION ALL VALUES ROW(`p`.`Int`), ROW(@__i_0)) AS `v`) = 35 +"""); + } + else + { + var exception = await Assert.ThrowsAsync(() => base.Inline_collection_of_nullable_value_type_Max(async)); + Assert.True(exception.Message is "Field reference 'p.Int' can't be used in table value constructor" + or "Unknown table 'p' in order clause"); + } + } + + public override async Task Inline_collection_of_nullable_value_type_with_null_Min(bool async) + { + if (AppConfig.ServerVersion.Supports.FieldReferenceInTableValueConstructor) + { + await base.Inline_collection_of_nullable_value_type_with_null_Min(async); + + AssertSql( +""" +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE ( + SELECT MIN(`v`.`Value`) + FROM (SELECT CAST(30 AS signed) AS `Value` UNION ALL VALUES ROW(`p`.`NullableInt`), ROW(NULL)) AS `v`) = 30 +"""); + } + else + { + var exception = await Assert.ThrowsAsync(() => base.Inline_collection_of_nullable_value_type_with_null_Min(async)); + Assert.True(exception.Message is "Field reference 'p.NullableInt' can't be used in table value constructor" + or "Unknown table 'p' in order clause"); + } + } + + public override async Task Inline_collection_of_nullable_value_type_with_null_Max(bool async) + { + if (AppConfig.ServerVersion.Supports.FieldReferenceInTableValueConstructor) + { + await base.Inline_collection_of_nullable_value_type_with_null_Max(async); + + AssertSql( +""" +SELECT `p`.`Id`, `p`.`Bool`, `p`.`Bools`, `p`.`DateTime`, `p`.`DateTimes`, `p`.`Enum`, `p`.`Enums`, `p`.`Int`, `p`.`Ints`, `p`.`NullableInt`, `p`.`NullableInts`, `p`.`NullableString`, `p`.`NullableStrings`, `p`.`String`, `p`.`Strings` +FROM `PrimitiveCollectionsEntity` AS `p` +WHERE ( + SELECT MAX(`v`.`Value`) + FROM (SELECT CAST(30 AS signed) AS `Value` UNION ALL VALUES ROW(`p`.`NullableInt`), ROW(NULL)) AS `v`) = 30 +"""); + } + else + { + var exception = await Assert.ThrowsAsync(() => base.Inline_collection_of_nullable_value_type_with_null_Max(async)); + Assert.True(exception.Message is "Field reference 'p.NullableInt' can't be used in table value constructor" + or "Unknown table 'p' in order clause"); + } + } + + public override async Task Inline_collection_Contains_with_EF_Parameter(bool async) + { + await base.Inline_collection_Contains_with_EF_Parameter(async); + + AssertSql(); + } + + public override async Task Inline_collection_Count_with_column_predicate_with_EF_Parameter(bool async) + { + await base.Inline_collection_Count_with_column_predicate_with_EF_Parameter(async); + + AssertSql(); + } + + public override async Task Parameter_collection_HashSet_of_ints_Contains_int(bool async) + { + await base.Parameter_collection_HashSet_of_ints_Contains_int(async); + + AssertSql(); + } + + public override async Task Column_collection_Count_with_predicate(bool async) + { + await base.Column_collection_Count_with_predicate(async); + + AssertSql(); + } + + public override async Task Column_collection_Where_Count(bool async) + { + await base.Column_collection_Where_Count(async); + + AssertSql(); + } + + [SupportedServerVersionCondition(nameof(ServerVersionSupport.WhereSubqueryReferencesOuterQuery))] + public override async Task Inline_collection_value_index_Column(bool async) + { + await base.Inline_collection_value_index_Column(async); + + AssertSql(); + } + + [SupportedServerVersionCondition(nameof(ServerVersionSupport.WhereSubqueryReferencesOuterQuery))] + public override async Task Inline_collection_List_value_index_Column(bool async) + { + await base.Inline_collection_List_value_index_Column(async); + + AssertSql(); + } + + public override async Task Column_collection_First(bool async) + { + await base.Column_collection_First(async); + + AssertSql(); + } + + public override async Task Column_collection_FirstOrDefault(bool async) + { + await base.Column_collection_FirstOrDefault(async); + + AssertSql(); + } + + public override async Task Column_collection_Single(bool async) + { + await base.Column_collection_Single(async); + + AssertSql(); + } + + public override async Task Column_collection_SingleOrDefault(bool async) + { + await base.Column_collection_SingleOrDefault(async); + + AssertSql(); + } + + public override async Task Column_collection_Where_Skip(bool async) + { + await base.Column_collection_Where_Skip(async); + + AssertSql(); + } + + public override async Task Column_collection_Where_Take(bool async) + { + await base.Column_collection_Where_Take(async); + + AssertSql(); + } + + public override async Task Column_collection_Where_Skip_Take(bool async) + { + await base.Column_collection_Where_Skip_Take(async); + + AssertSql(); + } + + public override async Task Column_collection_Contains_over_subquery(bool async) + { + await base.Column_collection_Contains_over_subquery(async); + + AssertSql(); + } + + public override async Task Column_collection_Where_ElementAt(bool async) + { + await base.Column_collection_Where_ElementAt(async); + + AssertSql(); + } + + public override async Task Column_collection_SelectMany_with_filter(bool async) + { + await base.Column_collection_SelectMany_with_filter(async); + + AssertSql(); + } + + public override async Task Column_collection_SelectMany_with_Select_to_anonymous_type(bool async) + { + await base.Column_collection_SelectMany_with_Select_to_anonymous_type(async); + + AssertSql(); + } + + public override async Task Parameter_collection_with_type_inference_for_JsonScalarExpression(bool async) + { + await base.Parameter_collection_with_type_inference_for_JsonScalarExpression(async); + + AssertSql(); + } + + public override async Task Column_collection_Where_Union(bool async) + { + await base.Column_collection_Where_Union(async); + + AssertSql(); + } + + public override async Task Project_inline_collection(bool async) + { + await base.Project_inline_collection(async); + + AssertSql( +""" +SELECT `p`.`String` +FROM `PrimitiveCollectionsEntity` AS `p` +"""); + } + + public override async Task Project_inline_collection_with_Union(bool async) + { + await base.Project_inline_collection_with_Union(async); + + AssertSql( +""" +SELECT `p`.`Id`, `u`.`Value` +FROM `PrimitiveCollectionsEntity` AS `p` +LEFT JOIN LATERAL ( + SELECT `p`.`String` AS `Value` + UNION + SELECT `p0`.`String` AS `Value` + FROM `PrimitiveCollectionsEntity` AS `p0` +) AS `u` ON TRUE +ORDER BY `p`.`Id` +"""); + } + [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); @@ -1839,7 +2252,7 @@ private void AssertSql(params string[] expected) private PrimitiveCollectionsContext CreateContext() => Fixture.CreateContext(); - public class PrimitiveCollectionsQueryMySqlFixture : PrimitiveCollectionsQueryFixtureBase + public class PrimitiveCollectionsQueryMySqlFixture : PrimitiveCollectionsQueryFixtureBase, ITestSqlLoggerFactory { public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; diff --git a/test/EFCore.MySql.FunctionalTests/Query/QueryNavigationsMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/QueryNavigationsMySqlTest.cs index f160d6714..3701781eb 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/QueryNavigationsMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/QueryNavigationsMySqlTest.cs @@ -20,9 +20,6 @@ public NorthwindNavigationsQueryMySqlTest( //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - [ConditionalTheory(Skip = "Issue #573")] public override Task Where_subquery_on_navigation(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/SpatialGeographyQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/SpatialGeographyQueryMySqlTest.cs index cbce16518..e54cf9031 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/SpatialGeographyQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/SpatialGeographyQueryMySqlTest.cs @@ -2,6 +2,7 @@ using System.Collections.Generic; using System.Linq; using System.Threading; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Query; @@ -156,10 +157,10 @@ public SpatialGeographyContext(DbContextOptions options) { } - public static void Seed(SpatialGeographyContext context, GeometryFactory factory) + public static async Task SeedAsync(SpatialGeographyContext context, GeometryFactory factory) { context.AddRange(SpatialGeographyData.CreateCities(factory)); - context.SaveChanges(); + await context.SaveChangesAsync(); } public class City @@ -202,7 +203,7 @@ public virtual IQueryable Set() } // TODO: Inherit from SpatialQueryRelationalFixture. - public class SpatialGeographyQueryMySqlFixture : SharedStoreFixtureBase, IQueryFixtureBase + public class SpatialGeographyQueryMySqlFixture : SharedStoreFixtureBase, IQueryFixtureBase, ITestSqlLoggerFactory { private GeometryFactory _geometryFactory; @@ -247,8 +248,8 @@ public override SpatialGeographyContext CreateContext() return context; } - protected override void Seed(SpatialGeographyContext context) - => SpatialGeographyContext.Seed(context, GeometryFactory); + protected override Task SeedAsync(SpatialGeographyContext context) + => SpatialGeographyContext.SeedAsync(context, GeometryFactory); public Func GetContextCreator() => CreateContext; diff --git a/test/EFCore.MySql.FunctionalTests/Query/SpatialQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/SpatialQueryMySqlTest.cs index 530286547..58f859f65 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/SpatialQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/SpatialQueryMySqlTest.cs @@ -1,10 +1,12 @@ -using System.Linq; +using System.Linq; using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestModels.SpatialModel; using NetTopologySuite.Geometries; using NetTopologySuite.Geometries.Utilities; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.Infrastructure; +using Pomelo.EntityFrameworkCore.MySql.Tests; using Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes; using Xunit; using Xunit.Abstractions; @@ -77,6 +79,1005 @@ public override Task Combine_aggregate(bool async) Assert.Equal(eCollection.Geometries, aCollection.Geometries); }); + public override async Task SimpleSelect(bool async) + { + await base.SimpleSelect(async); + + AssertSql( +""" +SELECT `p`.`Id`, `p`.`Geometry`, `p`.`Group`, `p`.`Point`, `p`.`PointM`, `p`.`PointZ`, `p`.`PointZM` +FROM `PointEntity` AS `p` +""", + // + """ +SELECT `l`.`Id`, `l`.`LineString` +FROM `LineStringEntity` AS `l` +""", + // + """ +SELECT `p`.`Id`, `p`.`Polygon` +FROM `PolygonEntity` AS `p` +""", + // + """ +SELECT `m`.`Id`, `m`.`MultiLineString` +FROM `MultiLineStringEntity` AS `m` +"""); + } + + public override async Task WithConversion(bool async) + { + await base.WithConversion(async); + + AssertSql( +""" +SELECT `g`.`Id`, `g`.`Location` +FROM `GeoPointEntity` AS `g` +"""); + } + + public override async Task Area(bool async) + { + await base.Area(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_Area(`p`.`Polygon`) AS `Area` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task AsBinary(bool async) + { + await base.AsBinary(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_AsBinary(`p`.`Point`) AS `Binary` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task AsBinary_with_null_check(bool async) + { + await base.AsBinary_with_null_check(async); + + AssertSql( +""" +SELECT `p`.`Id`, CASE + WHEN `p`.`Point` IS NULL THEN NULL + ELSE ST_AsBinary(`p`.`Point`) +END AS `Binary` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task AsText(bool async) + { + await base.AsText(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_AsText(`p`.`Point`) AS `Text` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Buffer(bool async) + { + await base.Buffer(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_Buffer(`p`.`Polygon`, 1.0) AS `Buffer` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task Centroid(bool async) + { + await base.Centroid(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_Centroid(`p`.`Polygon`) AS `Centroid` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task EnvelopeCombine_aggregate(bool async) + { + await base.EnvelopeCombine_aggregate(async); + + AssertSql( +""" +SELECT `p1`.`Group`, `p2`.`Point`, `p2`.`Id` +FROM ( + SELECT `p`.`Group` + FROM `PointEntity` AS `p` + WHERE `p`.`Point` IS NOT NULL + GROUP BY `p`.`Group` +) AS `p1` +LEFT JOIN ( + SELECT `p0`.`Point`, `p0`.`Id`, `p0`.`Group` + FROM `PointEntity` AS `p0` + WHERE `p0`.`Point` IS NOT NULL +) AS `p2` ON `p1`.`Group` = `p2`.`Group` +ORDER BY `p1`.`Group` +"""); + } + + public override async Task Contains(bool async) + { + await base.Contains(async); + + AssertSql( +""" +@__point_0='0x000000000101000000000000000000D03F000000000000D03F' (DbType = Binary) + +SELECT `p`.`Id`, ST_Contains(`p`.`Polygon`, @__point_0) AS `Contains` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task ConvexHull_aggregate(bool async) + { + await base.ConvexHull_aggregate(async); + + AssertSql( +""" +SELECT `p1`.`Group`, `p2`.`Point`, `p2`.`Id` +FROM ( + SELECT `p`.`Group` + FROM `PointEntity` AS `p` + WHERE `p`.`Point` IS NOT NULL + GROUP BY `p`.`Group` +) AS `p1` +LEFT JOIN ( + SELECT `p0`.`Point`, `p0`.`Id`, `p0`.`Group` + FROM `PointEntity` AS `p0` + WHERE `p0`.`Point` IS NOT NULL +) AS `p2` ON `p1`.`Group` = `p2`.`Group` +ORDER BY `p1`.`Group` +"""); + } + + public override async Task IGeometryCollection_Count(bool async) + { + await base.IGeometryCollection_Count(async); + + AssertSql( +""" +SELECT `m`.`Id`, ST_NumGeometries(`m`.`MultiLineString`) AS `Count` +FROM `MultiLineStringEntity` AS `m` +"""); + } + + public override async Task LineString_Count(bool async) + { + await base.LineString_Count(async); + + AssertSql( +""" +SELECT `l`.`Id`, ST_NumPoints(`l`.`LineString`) AS `Count` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task Crosses(bool async) + { + await base.Crosses(async); + + AssertSql( +""" +@__lineString_0='0x00000000010200000002000000000000000000E03F000000000000E0BF000000...' (DbType = Binary) + +SELECT `l`.`Id`, ST_Crosses(`l`.`LineString`, @__lineString_0) AS `Crosses` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task Difference(bool async) + { + await base.Difference(async); + + AssertSql( +""" +@__polygon_0='0x0000000001030000000100000004000000000000000000000000000000000000...' (DbType = Binary) + +SELECT `p`.`Id`, ST_Difference(`p`.`Polygon`, @__polygon_0) AS `Difference` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task Dimension(bool async) + { + await base.Dimension(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_Dimension(`p`.`Point`) AS `Dimension` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Disjoint_with_cast_to_nullable(bool async) + { + await base.Disjoint_with_cast_to_nullable(async); + + AssertSql( +""" +@__point_0='0x000000000101000000000000000000F03F000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, ST_Disjoint(`p`.`Polygon`, @__point_0) AS `Disjoint` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task Disjoint_with_null_check(bool async) + { + await base.Disjoint_with_null_check(async); + + AssertSql( +""" +@__point_0='0x000000000101000000000000000000F03F000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, CASE + WHEN `p`.`Polygon` IS NULL THEN NULL + ELSE ST_Disjoint(`p`.`Polygon`, @__point_0) +END AS `Disjoint` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task Distance_with_null_check(bool async) + { + await base.Distance_with_null_check(async); + + AssertSql( + AppConfig.ServerVersion.Supports.SpatialDistanceSphereFunction + ? """ +@__point_0='0x0000000001010000000000000000000000000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, CASE + WHEN ST_SRID(`p`.`Point`) = 4326 THEN ST_Distance_Sphere(`p`.`Point`, @__point_0) + ELSE ST_Distance(`p`.`Point`, @__point_0) +END AS `Distance` +FROM `PointEntity` AS `p` +""" + : """ +@__point_0='0x0000000001010000000000000000000000000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, CASE + WHEN ST_SRID(`p`.`Point`) = 4326 THEN CASE + WHEN (((((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0) = 0.0) AND (((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0) = 0.0)) OR (((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) = 0.0)) OR (((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) = 0.0) THEN 0.0 + ELSE ((2.0 * ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) * 6378137.0) * (1.0 + (((6378137.0 - 6356752.3142451793) / 6378137.0) * (((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) - 1.0) / (2.0 * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) * POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) * POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) - ((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) + 1.0) / (2.0 * ((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) * POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) * POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) + END + ELSE ST_Distance(`p`.`Point`, @__point_0) +END AS `Distance` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Distance_with_cast_to_nullable(bool async) + { + await base.Distance_with_cast_to_nullable(async); + + AssertSql( + AppConfig.ServerVersion.Supports.SpatialDistanceSphereFunction + ? """ +@__point_0='0x0000000001010000000000000000000000000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, CASE + WHEN ST_SRID(`p`.`Point`) = 4326 THEN ST_Distance_Sphere(`p`.`Point`, @__point_0) + ELSE ST_Distance(`p`.`Point`, @__point_0) +END AS `Distance` +FROM `PointEntity` AS `p` +""" + : """ +@__point_0='0x0000000001010000000000000000000000000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, CASE + WHEN ST_SRID(`p`.`Point`) = 4326 THEN CASE + WHEN (((((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0) = 0.0) AND (((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0) = 0.0)) OR (((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) = 0.0)) OR (((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) = 0.0) THEN 0.0 + ELSE ((2.0 * ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) * 6378137.0) * (1.0 + (((6378137.0 - 6356752.3142451793) / 6378137.0) * (((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) - 1.0) / (2.0 * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) * POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) * POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) - ((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) + 1.0) / (2.0 * ((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) * POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) * POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) + END + ELSE ST_Distance(`p`.`Point`, @__point_0) +END AS `Distance` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Distance_geometry(bool async) + { + await base.Distance_geometry(async); + + AssertSql( + AppConfig.ServerVersion.Supports.SpatialDistanceSphereFunction + ? """ +@__point_0='0x0000000001010000000000000000000000000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, CASE + WHEN ST_SRID(`p`.`Geometry`) = 4326 THEN ST_Distance_Sphere(`p`.`Geometry`, @__point_0) + ELSE ST_Distance(`p`.`Geometry`, @__point_0) +END AS `Distance` +FROM `PointEntity` AS `p` +""" + : """ +@__point_0='0x0000000001010000000000000000000000000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, CASE + WHEN ST_SRID(`p`.`Geometry`) = 4326 THEN CASE + WHEN (((((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0) = 0.0) AND (((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0) = 0.0)) OR (((POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) = 0.0)) OR (((POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) = 0.0) THEN 0.0 + ELSE ((2.0 * ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) * 6378137.0) * (1.0 + (((6378137.0 - 6356752.3142451793) / 6378137.0) * (((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) - 1.0) / (2.0 * ((POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) * POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) * POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) - ((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) + 1.0) / (2.0 * ((POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Geometry`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) * POWER(COS((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) * POWER(SIN((((ST_Y(`p`.`Geometry`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) + END + ELSE ST_Distance(`p`.`Geometry`, @__point_0) +END AS `Distance` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Distance_constant(bool async) + { + await base.Distance_constant(async); + + AssertSql( + AppConfig.ServerVersion.Supports.SpatialDistanceSphereFunction + ? """ +SELECT `p`.`Id`, CASE + WHEN ST_SRID(`p`.`Point`) = 4326 THEN ST_Distance_Sphere(`p`.`Point`, X'0000000001010000000000000000000000000000000000F03F') + ELSE ST_Distance(`p`.`Point`, X'0000000001010000000000000000000000000000000000F03F') +END AS `Distance` +FROM `PointEntity` AS `p` +""" + : """ +SELECT `p`.`Id`, CASE + WHEN ST_SRID(`p`.`Point`) = 4326 THEN CASE + WHEN (((((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0) = 0.0) AND (((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0) = 0.0)) OR (((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))) = 0.0)) OR (((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))) = 0.0) THEN 0.0 + ELSE ((2.0 * ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)))))) * 6378137.0) * (1.0 + (((6378137.0 - 6356752.3142451793) / 6378137.0) * (((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)))))) - 1.0) / (2.0 * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))))) * POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) * POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) - ((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)))))) + 1.0) / (2.0 * ((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))))) * POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2)) * POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0)) / 2.0), 2))))) + END + ELSE ST_Distance(`p`.`Point`, X'0000000001010000000000000000000000000000000000F03F') +END AS `Distance` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Distance_constant_lhs(bool async) + { + await base.Distance_constant_lhs(async); + + AssertSql( + AppConfig.ServerVersion.Supports.SpatialDistanceSphereFunction + ? """ +SELECT `p`.`Id`, CASE + WHEN ST_SRID(X'0000000001010000000000000000000000000000000000F03F') = 4326 THEN ST_Distance_Sphere(X'0000000001010000000000000000000000000000000000F03F', `p`.`Point`) + ELSE ST_Distance(X'0000000001010000000000000000000000000000000000F03F', `p`.`Point`) +END AS `Distance` +FROM `PointEntity` AS `p` +""" + : """ +SELECT `p`.`Id`, CASE + WHEN ST_SRID(X'0000000001010000000000000000000000000000000000F03F') = 4326 THEN CASE + WHEN (((((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0) = 0.0) AND (((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0) = 0.0)) OR (((POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))) = 0.0)) OR (((POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))) = 0.0) THEN 0.0 + ELSE ((2.0 * ATAN(SQRT(((POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)))))) * 6378137.0) * (1.0 + (((6378137.0 - 6356752.3142451793) / 6378137.0) * (((((((3.0 * SQRT(((POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)))))) - 1.0) / (2.0 * ((POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))))) * POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) * POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) - ((((((3.0 * SQRT(((POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)))))) + 1.0) / (2.0 * ((POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_X(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))))) * POWER(COS((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) + ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2)) * POWER(SIN((((ST_Y(X'0000000001010000000000000000000000000000000000F03F') * PI()) / 180.0) - ((ST_Y(`p`.`Point`) * PI()) / 180.0)) / 2.0), 2))))) + END + ELSE ST_Distance(X'0000000001010000000000000000000000000000000000F03F', `p`.`Point`) +END AS `Distance` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Distance_on_converted_geometry_type(bool async) + { + await base.Distance_on_converted_geometry_type(async); + + AssertSql( +""" +SELECT `g`.`Id`, `g`.`Location` +FROM `GeoPointEntity` AS `g` +"""); + } + + public override async Task Distance_on_converted_geometry_type_lhs(bool async) + { + await base.Distance_on_converted_geometry_type_lhs(async); + + AssertSql( +""" +SELECT `g`.`Id`, `g`.`Location` +FROM `GeoPointEntity` AS `g` +"""); + } + + public override async Task Distance_on_converted_geometry_type_constant(bool async) + { + await base.Distance_on_converted_geometry_type_constant(async); + + AssertSql( +""" +SELECT `g`.`Id`, `g`.`Location` +FROM `GeoPointEntity` AS `g` +"""); + } + + public override async Task Distance_on_converted_geometry_type_constant_lhs(bool async) + { + await base.Distance_on_converted_geometry_type_constant_lhs(async); + + AssertSql( +""" +SELECT `g`.`Id`, `g`.`Location` +FROM `GeoPointEntity` AS `g` +"""); + } + + public override async Task EndPoint(bool async) + { + await base.EndPoint(async); + + AssertSql( +""" +SELECT `l`.`Id`, ST_EndPoint(`l`.`LineString`) AS `EndPoint` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task Envelope(bool async) + { + await base.Envelope(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_Envelope(`p`.`Polygon`) AS `Envelope` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task EqualsTopologically(bool async) + { + await base.EqualsTopologically(async); + + AssertSql( +""" +@__point_0='0x00000000010100000000000000000000000000000000000000' (DbType = Binary) + +SELECT `p`.`Id`, ST_Equals(`p`.`Point`, @__point_0) AS `EqualsTopologically` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task ExteriorRing(bool async) + { + await base.ExteriorRing(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_ExteriorRing(`p`.`Polygon`) AS `ExteriorRing` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task GetGeometryN(bool async) + { + await base.GetGeometryN(async); + + AssertSql( +""" +SELECT `m`.`Id`, ST_GeometryN(`m`.`MultiLineString`, 0 + 1) AS `Geometry0` +FROM `MultiLineStringEntity` AS `m` +"""); + } + + public override async Task GetGeometryN_with_null_argument(bool async) + { + await base.GetGeometryN_with_null_argument(async); + + AssertSql( +""" +SELECT `m`.`Id`, ST_GeometryN(`m`.`MultiLineString`, ( + SELECT MAX(`m0`.`Id`) + FROM `MultiLineStringEntity` AS `m0` + WHERE FALSE) + 1) AS `Geometry0` +FROM `MultiLineStringEntity` AS `m` +"""); + } + + public override async Task GetInteriorRingN(bool async) + { + await base.GetInteriorRingN(async); + + AssertSql( +""" +SELECT `p`.`Id`, CASE + WHEN ST_NumInteriorRings(`p`.`Polygon`) = 0 THEN NULL + ELSE ST_InteriorRingN(`p`.`Polygon`, 0 + 1) +END AS `InteriorRing0` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task GetPointN(bool async) + { + await base.GetPointN(async); + + AssertSql( +""" +SELECT `l`.`Id`, ST_PointN(`l`.`LineString`, 0 + 1) AS `Point0` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task Intersection(bool async) + { + await base.Intersection(async); + + AssertSql( +""" +@__polygon_0='0x0000000001030000000100000004000000000000000000000000000000000000...' (DbType = Binary) + +SELECT `p`.`Id`, ST_Intersection(`p`.`Polygon`, @__polygon_0) AS `Intersection` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task Intersects(bool async) + { + await base.Intersects(async); + + AssertSql( +""" +@__lineString_0='0x00000000010200000002000000000000000000E03F000000000000E0BF000000...' (DbType = Binary) + +SELECT `l`.`Id`, ST_Intersects(`l`.`LineString`, @__lineString_0) AS `Intersects` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task ICurve_IsClosed(bool async) + { + await base.ICurve_IsClosed(async); + + AssertSql( +""" +SELECT `l`.`Id`, CASE + WHEN `l`.`LineString` IS NULL THEN NULL + ELSE ST_IsClosed(`l`.`LineString`) +END AS `IsClosed` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task IMultiCurve_IsClosed(bool async) + { + await base.IMultiCurve_IsClosed(async); + + AssertSql( +""" +SELECT `m`.`Id`, CASE + WHEN `m`.`MultiLineString` IS NULL THEN NULL + ELSE ST_IsClosed(`m`.`MultiLineString`) +END AS `IsClosed` +FROM `MultiLineStringEntity` AS `m` +"""); + } + + public override async Task IsEmpty(bool async) + { + await base.IsEmpty(async); + + AssertSql( +""" +SELECT `m`.`Id`, CASE + WHEN `m`.`MultiLineString` IS NULL THEN NULL + ELSE ST_IsEmpty(`m`.`MultiLineString`) +END AS `IsEmpty` +FROM `MultiLineStringEntity` AS `m` +"""); + } + + public override async Task IsRing(bool async) + { + await base.IsRing(async); + + AssertSql( + AppConfig.ServerVersion.Supports.SpatialFunctionAdditions + ? """ +SELECT `l`.`Id`, CASE + WHEN `l`.`LineString` IS NULL THEN NULL + ELSE ST_IsRing(`l`.`LineString`) +END AS `IsRing` +FROM `LineStringEntity` AS `l` +""" + : """ +SELECT `l`.`Id`, CASE + WHEN `l`.`LineString` IS NULL THEN NULL + ELSE ST_IsClosed(`l`.`LineString`) AND ST_IsSimple(`l`.`LineString`) +END AS `IsRing` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task IsSimple(bool async) + { + await base.IsSimple(async); + + AssertSql( +""" +SELECT `l`.`Id`, CASE + WHEN `l`.`LineString` IS NULL THEN NULL + ELSE ST_IsSimple(`l`.`LineString`) +END AS `IsSimple` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task IsWithinDistance(bool async) + { + await base.IsWithinDistance(async); + + AssertSql( + AppConfig.ServerVersion.Supports.SpatialDistanceSphereFunction + ? """ +@__point_0='0x0000000001010000000000000000000000000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, CASE + WHEN CASE + WHEN ST_SRID(`p`.`Point`) = 4326 THEN ST_Distance_Sphere(`p`.`Point`, @__point_0) + ELSE ST_Distance(`p`.`Point`, @__point_0) + END <= 1.0 THEN TRUE + ELSE FALSE +END AS `IsWithinDistance` +FROM `PointEntity` AS `p` +""" + : """ +@__point_0='0x0000000001010000000000000000000000000000000000F03F' (DbType = Binary) + +SELECT `p`.`Id`, CASE + WHEN CASE + WHEN ST_SRID(`p`.`Point`) = 4326 THEN CASE + WHEN (((((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0) = 0.0) AND (((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0) = 0.0)) OR (((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) = 0.0)) OR (((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) = 0.0) THEN 0.0 + ELSE ((2.0 * ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) * 6378137.0) * (1.0 + (((6378137.0 - 6356752.3142451793) / 6378137.0) * (((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) - 1.0) / (2.0 * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) * POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) * POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) - ((((((3.0 * SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) * ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) / ATAN(SQRT(((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))) / ((POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)))))) + 1.0) / (2.0 * ((POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(COS((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2)) + (POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2) * POWER(SIN((((ST_X(`p`.`Point`) * PI()) / 180.0) - ((ST_X(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) * POWER(COS((((ST_Y(`p`.`Point`) * PI()) / 180.0) + ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2)) * POWER(SIN((((ST_Y(`p`.`Point`) * PI()) / 180.0) - ((ST_Y(@__point_0) * PI()) / 180.0)) / 2.0), 2))))) + END + ELSE ST_Distance(`p`.`Point`, @__point_0) + END <= 1.0 THEN TRUE + ELSE FALSE +END AS `IsWithinDistance` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Item(bool async) + { + await base.Item(async); + + AssertSql( +""" +SELECT `m`.`Id`, ST_GeometryN(`m`.`MultiLineString`, 0 + 1) AS `Item0` +FROM `MultiLineStringEntity` AS `m` +"""); + } + + public override async Task Length(bool async) + { + await base.Length(async); + + AssertSql( +""" +SELECT `l`.`Id`, ST_Length(`l`.`LineString`) AS `Length` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task NumGeometries(bool async) + { + await base.NumGeometries(async); + + AssertSql( +""" +SELECT `m`.`Id`, ST_NumGeometries(`m`.`MultiLineString`) AS `NumGeometries` +FROM `MultiLineStringEntity` AS `m` +"""); + } + + public override async Task NumInteriorRings(bool async) + { + await base.NumInteriorRings(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_NumInteriorRings(`p`.`Polygon`) AS `NumInteriorRings` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task NumPoints(bool async) + { + await base.NumPoints(async); + + AssertSql( +""" +SELECT `l`.`Id`, ST_NumPoints(`l`.`LineString`) AS `NumPoints` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task OgcGeometryType(bool async) + { + await base.OgcGeometryType(async); + + AssertSql( +""" +SELECT `p`.`Id`, CASE ST_GeometryType(`p`.`Point`) + WHEN 'Point' THEN 1 + WHEN 'LineString' THEN 2 + WHEN 'Polygon' THEN 3 + WHEN 'MultiPoint' THEN 4 + WHEN 'MultiLineString' THEN 5 + WHEN 'MultiPolygon' THEN 6 + WHEN 'GeometryCollection' THEN 7 + WHEN 'CircularString' THEN 8 + WHEN 'CompoundCurve' THEN 9 + WHEN 'CurvePolygon' THEN 10 +END AS `OgcGeometryType` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Overlaps(bool async) + { + await base.Overlaps(async); + + AssertSql( +""" +@__polygon_0='0x0000000001030000000100000004000000000000000000000000000000000000...' (DbType = Binary) + +SELECT `p`.`Id`, ST_Overlaps(`p`.`Polygon`, @__polygon_0) AS `Overlaps` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task SRID(bool async) + { + await base.SRID(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_SRID(`p`.`Point`) AS `SRID` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task SRID_geometry(bool async) + { + await base.SRID_geometry(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_SRID(`p`.`Geometry`) AS `SRID` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task StartPoint(bool async) + { + await base.StartPoint(async); + + AssertSql( +""" +SELECT `l`.`Id`, ST_StartPoint(`l`.`LineString`) AS `StartPoint` +FROM `LineStringEntity` AS `l` +"""); + } + + public override async Task SymmetricDifference(bool async) + { + await base.SymmetricDifference(async); + + AssertSql( +""" +@__polygon_0='0x0000000001030000000100000004000000000000000000000000000000000000...' (DbType = Binary) + +SELECT `p`.`Id`, ST_SymDifference(`p`.`Polygon`, @__polygon_0) AS `SymmetricDifference` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task ToBinary(bool async) + { + await base.ToBinary(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_AsBinary(`p`.`Point`) AS `Binary` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task ToText(bool async) + { + await base.ToText(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_AsText(`p`.`Point`) AS `Text` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Touches(bool async) + { + await base.Touches(async); + + AssertSql( +""" +@__polygon_0='0x00000000010300000001000000040000000000000000000000000000000000F0...' (DbType = Binary) + +SELECT `p`.`Id`, ST_Touches(`p`.`Polygon`, @__polygon_0) AS `Touches` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task Union(bool async) + { + await base.Union(async); + + AssertSql( +""" +@__polygon_0='0x0000000001030000000100000004000000000000000000000000000000000000...' (DbType = Binary) + +SELECT `p`.`Id`, ST_Union(`p`.`Polygon`, @__polygon_0) AS `Union` +FROM `PolygonEntity` AS `p` +"""); + } + + public override async Task Union_aggregate(bool async) + { + await base.Union_aggregate(async); + + AssertSql( +""" +SELECT `p1`.`Group`, `p2`.`Point`, `p2`.`Id` +FROM ( + SELECT `p`.`Group` + FROM `PointEntity` AS `p` + WHERE `p`.`Point` IS NOT NULL + GROUP BY `p`.`Group` +) AS `p1` +LEFT JOIN ( + SELECT `p0`.`Point`, `p0`.`Id`, `p0`.`Group` + FROM `PointEntity` AS `p0` + WHERE `p0`.`Point` IS NOT NULL +) AS `p2` ON `p1`.`Group` = `p2`.`Group` +ORDER BY `p1`.`Group` +"""); + } + + public override async Task Within(bool async) + { + await base.Within(async); + + AssertSql( +""" +@__polygon_0='0x0000000001030000000100000005000000000000000000F0BF000000000000F0...' (DbType = Binary) + +SELECT `p`.`Id`, ST_Within(`p`.`Point`, @__polygon_0) AS `Within` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task X(bool async) + { + await base.X(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_X(`p`.`Point`) AS `X` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task Y(bool async) + { + await base.Y(async); + + AssertSql( +""" +SELECT `p`.`Id`, ST_Y(`p`.`Point`) AS `Y` +FROM `PointEntity` AS `p` +"""); + } + + public override async Task XY_with_collection_join(bool async) + { + await base.XY_with_collection_join(async); + + AssertSql( +""" +SELECT `p1`.`Id`, `p1`.`c`, `p1`.`c0`, `p0`.`Id`, `p0`.`Geometry`, `p0`.`Group`, `p0`.`Point`, `p0`.`PointM`, `p0`.`PointZ`, `p0`.`PointZM` +FROM ( + SELECT `p`.`Id`, ST_X(`p`.`Point`) AS `c`, ST_Y(`p`.`Point`) AS `c0` + FROM `PointEntity` AS `p` + ORDER BY `p`.`Id` + LIMIT 1 +) AS `p1` +LEFT JOIN `PointEntity` AS `p0` ON `p1`.`Id` = `p0`.`Id` +ORDER BY `p1`.`Id` +"""); + } + + public override async Task IsEmpty_equal_to_null(bool async) + { + await base.IsEmpty_equal_to_null(async); + + AssertSql( +""" +SELECT `p`.`Id` +FROM `PointEntity` AS `p` +WHERE CASE + WHEN `p`.`Point` IS NULL THEN NULL + ELSE ST_IsEmpty(`p`.`Point`) +END IS NULL +"""); + } + + public override async Task IsEmpty_not_equal_to_null(bool async) + { + await base.IsEmpty_not_equal_to_null(async); + + AssertSql( +""" +SELECT `p`.`Id` +FROM `PointEntity` AS `p` +WHERE CASE + WHEN `p`.`Point` IS NULL THEN NULL + ELSE ST_IsEmpty(`p`.`Point`) +END IS NOT NULL +"""); + } + + public override async Task Intersects_equal_to_null(bool async) + { + await base.Intersects_equal_to_null(async); + + AssertSql( +""" +@__lineString_0='0x00000000010200000002000000000000000000E03F000000000000E0BF000000...' (DbType = Binary) + +SELECT `l`.`Id` +FROM `LineStringEntity` AS `l` +WHERE ST_Intersects(`l`.`LineString`, @__lineString_0) IS NULL +""", + // + """ +@__lineString_0='0x00000000010200000002000000000000000000E03F000000000000E0BF000000...' (DbType = Binary) + +SELECT `l`.`Id` +FROM `LineStringEntity` AS `l` +WHERE ST_Intersects(@__lineString_0, `l`.`LineString`) IS NULL +"""); + } + + public override async Task Intersects_not_equal_to_null(bool async) + { + await base.Intersects_not_equal_to_null(async); + + AssertSql( +""" +@__lineString_0='0x00000000010200000002000000000000000000E03F000000000000E0BF000000...' (DbType = Binary) + +SELECT `l`.`Id` +FROM `LineStringEntity` AS `l` +WHERE ST_Intersects(`l`.`LineString`, @__lineString_0) IS NOT NULL +""", + // + """ +@__lineString_0='0x00000000010200000002000000000000000000E03F000000000000E0BF000000...' (DbType = Binary) + +SELECT `l`.`Id` +FROM `LineStringEntity` AS `l` +WHERE ST_Intersects(@__lineString_0, `l`.`LineString`) IS NOT NULL +"""); + } #region Not supported by MySQL and MariaDB @@ -91,6 +1092,10 @@ public override Task Combine_aggregate(bool async) #endregion + [ConditionalFact] + public virtual void Check_all_tests_overridden() + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); + private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); } diff --git a/test/EFCore.MySql.FunctionalTests/Query/SqlExecutorMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/SqlExecutorMySqlTest.cs index 0a69aa357..b986f224b 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/SqlExecutorMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/SqlExecutorMySqlTest.cs @@ -2,16 +2,16 @@ using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Query; -using Microsoft.EntityFrameworkCore.TestUtilities; +using Microsoft.EntityFrameworkCore.TestModels.ConcurrencyModel; using MySqlConnector; using Xunit; using Xunit.Abstractions; namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.Query { - public class SqlExecutorMySqlTest : SqlExecutorTestBase> + public class SqlExecutorMySqlTest : SqlExecutorTestBase> { - public SqlExecutorMySqlTest(NorthwindQueryMySqlFixture fixture, ITestOutputHelper testOutputHelper) + public SqlExecutorMySqlTest(NorthwindQueryMySqlFixture fixture, ITestOutputHelper testOutputHelper) : base(fixture) { Fixture.TestSqlLoggerFactory.Clear(); @@ -222,6 +222,25 @@ public override async Task Query_with_DbParameters_interpolated(bool async) Assert.Equal(DefaultSqlResult, actual); } + public override async Task Query_with_parameters_custom_converter(bool async) + { + // We have to reimplement the base method, because it uses double-quote delimiters, while MySQL uses ticks. + // await base.Query_with_parameters_custom_converter(async); + + var city = new City { Name = "London" }; + var contactTitle = "Sales Representative"; + + using var context = CreateContext(); + + var actual = async + ? await context.Database.ExecuteSqlAsync( + $@"SELECT COUNT(*) FROM `Customers` WHERE `City` = {city} AND `ContactTitle` = {contactTitle}") + : context.Database.ExecuteSql( + $@"SELECT COUNT(*) FROM `Customers` WHERE `City` = {city} AND `ContactTitle` = {contactTitle}"); + + Assert.Equal(-1, actual); + } + protected override DbParameter CreateDbParameter(string name, object value) => new MySqlParameter { diff --git a/test/EFCore.MySql.FunctionalTests/Query/SqlQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/SqlQueryMySqlTest.cs index f73a20297..3927e3cf4 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/SqlQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/SqlQueryMySqlTest.cs @@ -3,8 +3,10 @@ using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestUtilities; using MySqlConnector; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Pomelo.EntityFrameworkCore.MySql.Infrastructure; using Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes; +using Xunit; using Xunit.Abstractions; namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.Query; @@ -693,6 +695,181 @@ public override async Task Multiple_occurrences_of_SqlQuery_with_db_parameter_ad """); } + public override async Task Bad_data_error_handling_invalid_cast_key(bool async) + { + await base.Bad_data_error_handling_invalid_cast_key(async); + + AssertSql( +""" +SELECT `ProductName` AS `ProductID`, `ProductID` AS `ProductName`, `SupplierID`, `UnitPrice`, `UnitsInStock`, `Discontinued` + FROM `Products` +"""); + } + + public override async Task Bad_data_error_handling_invalid_cast(bool async) + { + await base.Bad_data_error_handling_invalid_cast(async); + + AssertSql( +""" +SELECT `ProductID`, `ProductName` AS `UnitPrice`, `ProductName`, `SupplierID`, `UnitsInStock`, `Discontinued` + FROM `Products` +"""); + } + + public override async Task Bad_data_error_handling_invalid_cast_projection(bool async) + { + await base.Bad_data_error_handling_invalid_cast_projection(async); + + AssertSql( +""" +SELECT `m`.`UnitPrice` +FROM ( + SELECT `ProductID`, `ProductName` AS `UnitPrice`, `ProductName`, `UnitsInStock`, `Discontinued` + FROM `Products` +) AS `m` +"""); + } + + public override async Task Bad_data_error_handling_invalid_cast_no_tracking(bool async) + { + await base.Bad_data_error_handling_invalid_cast_no_tracking(async); + + AssertSql( +""" +SELECT `ProductName` AS `ProductID`, `ProductID` AS `ProductName`, `SupplierID`, `UnitPrice`, `UnitsInStock`, `Discontinued` + FROM `Products` +"""); + } + + public override async Task Bad_data_error_handling_null(bool async) + { + await base.Bad_data_error_handling_null(async); + + AssertSql( +""" +SELECT `ProductID`, `ProductName`, `SupplierID`, `UnitPrice`, `UnitsInStock`, NULL AS `Discontinued` + FROM `Products` +"""); + } + + public override async Task Bad_data_error_handling_null_projection(bool async) + { + await base.Bad_data_error_handling_null_projection(async); + + AssertSql( +""" +SELECT `m`.`Discontinued` +FROM ( + SELECT `ProductID`, `ProductName`, `SupplierID`, `UnitPrice`, `UnitsInStock`, NULL AS `Discontinued` + FROM `Products` +) AS `m` +"""); + } + + public override async Task Bad_data_error_handling_null_no_tracking(bool async) + { + await base.Bad_data_error_handling_null_no_tracking(async); + + AssertSql( +""" +SELECT `ProductID`, `ProductName`, `SupplierID`, `UnitPrice`, `UnitsInStock`, NULL AS `Discontinued` + FROM `Products` +"""); + } + + public override async Task SqlQueryRaw_queryable_simple_mapped_type(bool async) + { + await base.SqlQueryRaw_queryable_simple_mapped_type(async); + + AssertSql( +""" +SELECT * FROM `Customers` WHERE `ContactName` LIKE '%z%' +"""); + } + + public override async Task SqlQueryRaw_queryable_simple_columns_out_of_order_and_not_enough_columns_throws(bool async) + { + await base.SqlQueryRaw_queryable_simple_columns_out_of_order_and_not_enough_columns_throws(async); + + AssertSql( +""" +SELECT `PostalCode`, `Phone`, `Fax`, `CustomerID`, `Country`, `ContactTitle`, `ContactName`, `CompanyName`, `City`, `Address` FROM `Customers` +"""); + } + + public override async Task SqlQueryRaw_queryable_simple_different_cased_columns_and_not_enough_columns_throws(bool async) + { + await base.SqlQueryRaw_queryable_simple_different_cased_columns_and_not_enough_columns_throws(async); + + AssertSql( +""" +SELECT `PostalCODE`, `Phone`, `Fax`, `CustomerID`, `Country`, `ContactTitle`, `ContactName`, `CompanyName`, `City`, `Address` FROM `Customers` +"""); + } + + public override async Task SqlQueryRaw_queryable_simple_projection_not_composed(bool async) + { + await base.SqlQueryRaw_queryable_simple_projection_not_composed(async); + + AssertSql( +""" +SELECT `m`.`CustomerID`, `m`.`City` +FROM ( + SELECT * FROM `Customers` +) AS `m` +"""); + } + + public override void Ad_hoc_type_with_reference_navigation_throws() + { + base.Ad_hoc_type_with_reference_navigation_throws(); + + AssertSql(); + } + + public override void Ad_hoc_type_with_collection_navigation_throws() + { + base.Ad_hoc_type_with_collection_navigation_throws(); + + AssertSql(); + } + + public override void Ad_hoc_type_with_unmapped_property_throws() + { + base.Ad_hoc_type_with_unmapped_property_throws(); + + AssertSql(); + } + + public override async Task SqlQueryRaw_then_String_Length(bool async) + { + await base.SqlQueryRaw_then_String_Length(async); + + AssertSql( +""" +SELECT `s`.`Value` +FROM ( + SELECT 'x' AS `Value` FROM `Customers` +) AS `s` +WHERE CHAR_LENGTH(`s`.`Value`) = 0 +"""); + } + + public override async Task SqlQueryRaw_then_String_ToUpper_String_Length(bool async) + { + await base.SqlQueryRaw_then_String_ToUpper_String_Length(async); + + AssertSql( +""" +SELECT `s`.`Value` +FROM ( + SELECT 'x' AS `Value` FROM `Customers` +) AS `s` +WHERE CHAR_LENGTH(UPPER(`s`.`Value`)) = 0 +"""); + } + [SupportedServerVersionCondition(nameof(ServerVersionSupport.CommonTableExpressions))] public override async Task SqlQueryRaw_composed_with_common_table_expression(bool async) { @@ -711,6 +888,10 @@ public override async Task SqlQueryRaw_composed_with_common_table_expression(boo """); } + [ConditionalFact] + public virtual void Check_all_tests_overridden() + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); + protected override DbParameter CreateDbParameter(string name, object value) => new MySqlParameter { ParameterName = name, Value = value }; diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPCFiltersInheritanceQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPCFiltersInheritanceQueryMySqlTest.cs index 0428cf979..51e87d75b 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPCFiltersInheritanceQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPCFiltersInheritanceQueryMySqlTest.cs @@ -1,6 +1,7 @@ using System.Threading.Tasks; using Microsoft.EntityFrameworkCore.Query; using Microsoft.EntityFrameworkCore.TestUtilities; +using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Xunit; using Xunit.Abstractions; @@ -19,7 +20,7 @@ public TPCFiltersInheritanceQueryMySqlTest( [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Can_use_of_type_animal(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPCGearsOfWarQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPCGearsOfWarQueryMySqlTest.cs index af075ae32..68675a4ba 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPCGearsOfWarQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPCGearsOfWarQueryMySqlTest.cs @@ -24,12 +24,9 @@ public TPCGearsOfWarQueryMySqlTest(TPCGearsOfWarQueryMySqlFixture fixture, ITest //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Entity_equality_empty(bool async) { @@ -683,7 +680,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & 2) > 0 +WHERE CAST(`u`.`Rank` & 2 AS signed) > 0 """, // """ @@ -695,7 +692,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & 2) = 2 +WHERE CAST(`u`.`Rank` & 2 AS signed) = 2 """); } @@ -713,7 +710,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & 1) = 1 +WHERE CAST(`u`.`Rank` & 1 AS signed) = 1 """, // """ @@ -725,7 +722,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (CAST(`u`.`Rank` AS signed) & 1) = 1 +WHERE CAST(CAST(`u`.`Rank` AS signed) & 1 AS signed) = 1 """, // """ @@ -737,7 +734,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (CAST(`u`.`Rank` AS signed) & 1) = 1 +WHERE CAST(CAST(`u`.`Rank` AS signed) & 1 AS signed) = 1 """); } @@ -749,7 +746,7 @@ public override async Task Where_bitwise_and_nullable_enum_with_constant(bool as """ SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` FROM `Weapons` AS `w` -WHERE (`w`.`AmmunitionType` & 1) > 0 +WHERE CAST(`w`.`AmmunitionType` & 1 AS signed) > 0 """); } @@ -761,7 +758,7 @@ public override async Task Where_bitwise_and_nullable_enum_with_null_constant(bo """ SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` FROM `Weapons` AS `w` -WHERE (`w`.`AmmunitionType` & NULL) > 0 +WHERE CAST(`w`.`AmmunitionType` & NULL AS signed) > 0 """); } @@ -775,7 +772,7 @@ public override async Task Where_bitwise_and_nullable_enum_with_non_nullable_par SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` FROM `Weapons` AS `w` -WHERE (`w`.`AmmunitionType` & @__ammunitionType_0) > 0 +WHERE CAST(`w`.`AmmunitionType` & @__ammunitionType_0 AS signed) > 0 """); } @@ -789,13 +786,13 @@ public override async Task Where_bitwise_and_nullable_enum_with_nullable_paramet SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` FROM `Weapons` AS `w` -WHERE (`w`.`AmmunitionType` & @__ammunitionType_0) > 0 +WHERE CAST(`w`.`AmmunitionType` & @__ammunitionType_0 AS signed) > 0 """, // """ SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` FROM `Weapons` AS `w` -WHERE (`w`.`AmmunitionType` & NULL) > 0 +WHERE CAST(`w`.`AmmunitionType` & NULL AS signed) > 0 """); } @@ -813,7 +810,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` | 2) > 0 +WHERE CAST(`u`.`Rank` | 2 AS signed) > 0 """); } @@ -823,7 +820,7 @@ public override async Task Bitwise_projects_values_in_select(bool async) AssertSql( """ -SELECT (`u`.`Rank` & 2) = 2 AS `BitwiseTrue`, (`u`.`Rank` & 2) = 4 AS `BitwiseFalse`, `u`.`Rank` & 2 AS `BitwiseValue` +SELECT CAST(`u`.`Rank` & 2 AS signed) = 2 AS `BitwiseTrue`, CAST(`u`.`Rank` & 2 AS signed) = 4 AS `BitwiseFalse`, CAST(`u`.`Rank` & 2 AS signed) AS `BitwiseValue` FROM ( SELECT `g`.`Rank` FROM `Gears` AS `g` @@ -831,7 +828,7 @@ UNION ALL SELECT `o`.`Rank` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & 2) = 2 +WHERE CAST(`u`.`Rank` & 2 AS signed) = 2 LIMIT 1 """); } @@ -850,7 +847,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & 2) = 2 +WHERE CAST(`u`.`Rank` & 2 AS signed) = 2 """, // """ @@ -862,7 +859,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & 18) = 18 +WHERE CAST(`u`.`Rank` & 18 AS signed) = 18 """, // """ @@ -874,7 +871,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & 1) = 1 +WHERE CAST(`u`.`Rank` & 1 AS signed) = 1 """, // """ @@ -886,7 +883,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & 1) = 1 +WHERE CAST(`u`.`Rank` & 1 AS signed) = 1 """, // """ @@ -898,7 +895,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (2 & `u`.`Rank`) = `u`.`Rank` +WHERE CAST(2 & `u`.`Rank` AS signed) = `u`.`Rank` """); } @@ -916,7 +913,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & COALESCE(( +WHERE CAST(`u`.`Rank` & COALESCE(( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -926,7 +923,7 @@ UNION ALL FROM `Officers` AS `o0` ) AS `u0` ORDER BY `u0`.`Nickname`, `u0`.`SquadId` - LIMIT 1), 0)) = COALESCE(( + LIMIT 1), 0) AS signed) = COALESCE(( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -948,7 +945,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (2 & COALESCE(( +WHERE CAST(2 & COALESCE(( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -958,7 +955,7 @@ UNION ALL FROM `Officers` AS `o0` ) AS `u0` ORDER BY `u0`.`Nickname`, `u0`.`SquadId` - LIMIT 1), 0)) = COALESCE(( + LIMIT 1), 0) AS signed) = COALESCE(( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -986,7 +983,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE ((`u`.`Rank` & ( +WHERE (CAST(`u`.`Rank` & ( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -996,7 +993,7 @@ UNION ALL FROM `Officers` AS `o0` ) AS `u0` ORDER BY `u0`.`Nickname`, `u0`.`SquadId` - LIMIT 1)) = ( + LIMIT 1) AS signed) = ( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -1028,7 +1025,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE ((2 & ( +WHERE (CAST(2 & ( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -1038,7 +1035,7 @@ UNION ALL FROM `Officers` AS `o0` ) AS `u0` ORDER BY `u0`.`Nickname`, `u0`.`SquadId` - LIMIT 1)) = ( + LIMIT 1) AS signed) = ( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -1076,7 +1073,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE ((`u`.`Rank` & ( +WHERE (CAST(`u`.`Rank` & ( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -1086,7 +1083,7 @@ UNION ALL FROM `Officers` AS `o0` ) AS `u0` ORDER BY `u0`.`Nickname`, `u0`.`SquadId` - LIMIT 1)) = ( + LIMIT 1) AS signed) = ( SELECT `u0`.`Rank` FROM ( SELECT `g0`.`Nickname`, `g0`.`SquadId`, `g0`.`Rank` @@ -1126,7 +1123,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & @__parameter_0) = @__parameter_0 +WHERE CAST(`u`.`Rank` & @__parameter_0 AS signed) = @__parameter_0 """); } @@ -1146,7 +1143,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & @__parameter_0) = @__parameter_0 +WHERE CAST(`u`.`Rank` & @__parameter_0 AS signed) = @__parameter_0 """); } @@ -1156,7 +1153,7 @@ public override async Task Select_enum_has_flag(bool async) AssertSql( """ -SELECT (`u`.`Rank` & 2) = 2 AS `hasFlagTrue`, (`u`.`Rank` & 4) = 4 AS `hasFlagFalse` +SELECT CAST(`u`.`Rank` & 2 AS signed) = 2 AS `hasFlagTrue`, CAST(`u`.`Rank` & 4 AS signed) = 4 AS `hasFlagFalse` FROM ( SELECT `g`.`Rank` FROM `Gears` AS `g` @@ -1164,7 +1161,7 @@ UNION ALL SELECT `o`.`Rank` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & 2) = 2 +WHERE CAST(`u`.`Rank` & 2 AS signed) = 2 LIMIT 1 """); } @@ -1386,7 +1383,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`LeaderNickname` = 'Marcus') AND `u`.`LeaderNickname` IS NOT NULL +WHERE `u`.`LeaderNickname` = 'Marcus' """); } @@ -1407,8 +1404,8 @@ UNION ALL ) AS `u` WHERE CASE WHEN `u`.`LeaderNickname` IS NULL THEN NULL - ELSE (`u`.`LeaderNickname` LIKE '%us') AND `u`.`LeaderNickname` IS NOT NULL -END = TRUE + ELSE `u`.`LeaderNickname` LIKE '%us' +END """); } @@ -1429,8 +1426,7 @@ UNION ALL ) AS `u` WHERE CASE WHEN `u`.`LeaderNickname` IS NOT NULL THEN `u`.`LeaderNickname` LIKE '%us' - ELSE NULL -END = TRUE +END """); } @@ -1449,13 +1445,10 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (CASE - WHEN `u`.`LeaderNickname` IS NULL THEN NULL - ELSE CHAR_LENGTH(`u`.`LeaderNickname`) -END = 5) AND CASE +WHERE CASE WHEN `u`.`LeaderNickname` IS NULL THEN NULL ELSE CHAR_LENGTH(`u`.`LeaderNickname`) -END IS NOT NULL +END = 5 """); } @@ -1474,13 +1467,9 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (CASE - WHEN `u`.`LeaderNickname` IS NOT NULL THEN CHAR_LENGTH(`u`.`LeaderNickname`) - ELSE NULL -END = 5) AND CASE +WHERE CASE WHEN `u`.`LeaderNickname` IS NOT NULL THEN CHAR_LENGTH(`u`.`LeaderNickname`) - ELSE NULL -END IS NOT NULL +END = 5 """); } @@ -1499,13 +1488,9 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (CASE - WHEN `u`.`LeaderNickname` IS NOT NULL THEN CHAR_LENGTH(`u`.`LeaderNickname`) - ELSE NULL -END = 5) AND CASE +WHERE CASE WHEN `u`.`LeaderNickname` IS NOT NULL THEN CHAR_LENGTH(`u`.`LeaderNickname`) - ELSE NULL -END IS NOT NULL +END = 5 """); } @@ -1518,7 +1503,6 @@ public override async Task Select_null_propagation_optimization7(bool async) """ SELECT CASE WHEN `u`.`LeaderNickname` IS NOT NULL THEN CONCAT(`u`.`LeaderNickname`, `u`.`LeaderNickname`) - ELSE NULL END FROM ( SELECT `g`.`LeaderNickname` @@ -1572,7 +1556,6 @@ public override async Task Select_null_propagation_negative1(bool async) """ SELECT CASE WHEN `u`.`LeaderNickname` IS NOT NULL THEN CHAR_LENGTH(`u`.`Nickname`) = 5 - ELSE NULL END FROM ( SELECT `g`.`Nickname`, `g`.`LeaderNickname` @@ -1592,7 +1575,6 @@ public override async Task Select_null_propagation_negative2(bool async) """ SELECT CASE WHEN `u`.`LeaderNickname` IS NOT NULL THEN `u0`.`LeaderNickname` - ELSE NULL END FROM ( SELECT `g`.`LeaderNickname` @@ -1619,7 +1601,6 @@ public override async Task Select_null_propagation_negative3(bool async) """ SELECT `u0`.`Nickname`, CASE WHEN `u0`.`Nickname` IS NOT NULL AND (`u0`.`SquadId` IS NOT NULL) THEN `u0`.`LeaderNickname` IS NOT NULL - ELSE NULL END AS `Condition` FROM ( SELECT `g`.`HasSoulPatch` @@ -1696,8 +1677,7 @@ public override async Task Select_null_propagation_negative6(bool async) AssertSql( """ SELECT CASE - WHEN `u`.`LeaderNickname` IS NOT NULL THEN CHAR_LENGTH(`u`.`LeaderNickname`) <> CHAR_LENGTH(`u`.`LeaderNickname`) - ELSE NULL + WHEN `u`.`LeaderNickname` IS NOT NULL THEN FALSE END FROM ( SELECT `g`.`LeaderNickname` @@ -1717,7 +1697,6 @@ public override async Task Select_null_propagation_negative7(bool async) """ SELECT CASE WHEN `u`.`LeaderNickname` IS NOT NULL THEN TRUE - ELSE NULL END FROM ( SELECT `g`.`LeaderNickname` @@ -1737,7 +1716,6 @@ public override async Task Select_null_propagation_negative8(bool async) """ SELECT CASE WHEN `s`.`Id` IS NOT NULL THEN `c`.`Name` - ELSE NULL END FROM `Tags` AS `t` LEFT JOIN ( @@ -1759,8 +1737,7 @@ public override async Task Select_null_propagation_negative9(bool async) AssertSql( """ SELECT CASE - WHEN `u`.`LeaderNickname` IS NOT NULL THEN COALESCE(CHAR_LENGTH(`u`.`Nickname`) = 5, FALSE) - ELSE NULL + WHEN `u`.`LeaderNickname` IS NOT NULL THEN CHAR_LENGTH(`u`.`Nickname`) = 5 END FROM ( SELECT `g`.`Nickname`, `g`.`LeaderNickname` @@ -1798,7 +1775,6 @@ public override async Task Select_null_propagation_works_for_multiple_navigation """ SELECT CASE WHEN `c`.`Name` IS NOT NULL THEN `c`.`Name` - ELSE NULL END FROM `Tags` AS `t` LEFT JOIN ( @@ -3279,9 +3255,16 @@ public override async Task Coalesce_operator_in_predicate(bool async) AssertSql( """ -SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` -FROM `Weapons` AS `w` -WHERE COALESCE(`w`.`IsAutomatic`, FALSE) +SELECT `t`.`Id`, `t`.`GearNickName`, `t`.`GearSquadId`, `t`.`IssueDate`, `t`.`Note` +FROM `Tags` AS `t` +LEFT JOIN ( + SELECT `g`.`Nickname`, `g`.`SquadId`, `g`.`HasSoulPatch` + FROM `Gears` AS `g` + UNION ALL + SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`HasSoulPatch` + FROM `Officers` AS `o` +) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) +WHERE COALESCE(`u`.`HasSoulPatch`, FALSE) """); } @@ -3291,9 +3274,16 @@ public override async Task Coalesce_operator_in_predicate_with_other_conditions( AssertSql( """ -SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` -FROM `Weapons` AS `w` -WHERE (`w`.`AmmunitionType` = 1) AND COALESCE(`w`.`IsAutomatic`, FALSE) +SELECT `t`.`Id`, `t`.`GearNickName`, `t`.`GearSquadId`, `t`.`IssueDate`, `t`.`Note` +FROM `Tags` AS `t` +LEFT JOIN ( + SELECT `g`.`Nickname`, `g`.`SquadId`, `g`.`HasSoulPatch` + FROM `Gears` AS `g` + UNION ALL + SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`HasSoulPatch` + FROM `Officers` AS `o` +) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) +WHERE ((`t`.`Note` <> 'K.I.A.') OR `t`.`Note` IS NULL) AND COALESCE(`u`.`HasSoulPatch`, FALSE) """); } @@ -3303,8 +3293,15 @@ public override async Task Coalesce_operator_in_projection_with_other_conditions AssertSql( """ -SELECT ((`w`.`AmmunitionType` = 1) AND `w`.`AmmunitionType` IS NOT NULL) AND COALESCE(`w`.`IsAutomatic`, FALSE) -FROM `Weapons` AS `w` +SELECT ((`t`.`Note` <> 'K.I.A.') OR `t`.`Note` IS NULL) AND COALESCE(`u`.`HasSoulPatch`, FALSE) +FROM `Tags` AS `t` +LEFT JOIN ( + SELECT `g`.`Nickname`, `g`.`SquadId`, `g`.`HasSoulPatch` + FROM `Gears` AS `g` + UNION ALL + SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`HasSoulPatch` + FROM `Officers` AS `o` +) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) """); } @@ -3846,7 +3843,7 @@ public override async Task Where_datetimeoffset_now(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE `m`.`Timeline` <> UTC_TIMESTAMP() """); @@ -3858,7 +3855,7 @@ public override async Task Where_datetimeoffset_utcnow(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE `m`.`Timeline` <> UTC_TIMESTAMP() """); @@ -3872,7 +3869,7 @@ public override async Task Where_datetimeoffset_date_component(bool async) """ @__Date_0='0001-01-01T00:00:00.0000000' (DbType = DateTime) -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE CONVERT(`m`.`Timeline`, date) > @__Date_0 """); @@ -3884,7 +3881,7 @@ public override async Task Where_datetimeoffset_year_component(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(year FROM `m`.`Timeline`) = 2 """); @@ -3896,7 +3893,7 @@ public override async Task Where_datetimeoffset_month_component(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(month FROM `m`.`Timeline`) = 1 """); @@ -3908,7 +3905,7 @@ public override async Task Where_datetimeoffset_dayofyear_component(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE DAYOFYEAR(`m`.`Timeline`) = 2 """); @@ -3920,7 +3917,7 @@ public override async Task Where_datetimeoffset_day_component(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(day FROM `m`.`Timeline`) = 2 """); @@ -3936,7 +3933,7 @@ await AssertQuery( AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(hour FROM `m`.`Timeline`) = 8 """); @@ -3948,7 +3945,7 @@ public override async Task Where_datetimeoffset_minute_component(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(minute FROM `m`.`Timeline`) = 0 """); @@ -3960,7 +3957,7 @@ public override async Task Where_datetimeoffset_second_component(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(second FROM `m`.`Timeline`) = 0 """); @@ -3972,7 +3969,7 @@ public override async Task Where_datetimeoffset_millisecond_component(bool async AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE (EXTRACT(microsecond FROM `m`.`Timeline`)) DIV (1000) = 0 """); @@ -4211,7 +4208,7 @@ UNION ALL FROM `Officers` AS `o` ) AS `u` LEFT JOIN `Tags` AS `t` ON (`u`.`Nickname` = `t`.`GearNickName`) AND (`u`.`SquadId` = `t`.`GearSquadId`) - WHERE (`t`.`Note` = 'Foo') AND `t`.`Note` IS NOT NULL) + WHERE `t`.`Note` = 'Foo') """); } @@ -4968,7 +4965,6 @@ public override async Task Select_null_conditional_with_inheritance(bool async) """ SELECT CASE WHEN `l`.`CommanderName` IS NOT NULL THEN `l`.`CommanderName` - ELSE NULL END FROM `LocustHordes` AS `l` """); @@ -4982,7 +4978,6 @@ public override async Task Select_null_conditional_with_inheritance_negative(boo """ SELECT CASE WHEN `l`.`CommanderName` IS NOT NULL THEN `l`.`Eradicated` - ELSE NULL END FROM `LocustHordes` AS `l` """); @@ -5504,21 +5499,74 @@ UNION ALL """); } - public override async Task Enum_ToString_is_client_eval(bool async) + public override async Task ToString_enum_property_projection(bool async) { - await base.Enum_ToString_is_client_eval(async); + await base.ToString_enum_property_projection(async); AssertSql( """ -SELECT `u`.`Rank` +SELECT CASE `u`.`Rank` + WHEN 0 THEN 'None' + WHEN 1 THEN 'Private' + WHEN 2 THEN 'Corporal' + WHEN 4 THEN 'Sergeant' + WHEN 8 THEN 'Lieutenant' + WHEN 16 THEN 'Captain' + WHEN 32 THEN 'Major' + WHEN 64 THEN 'Colonel' + WHEN 128 THEN 'General' + ELSE CAST(`u`.`Rank` AS char) +END FROM ( - SELECT `g`.`Nickname`, `g`.`SquadId`, `g`.`Rank` + SELECT `g`.`Rank` FROM `Gears` AS `g` UNION ALL - SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`Rank` + SELECT `o`.`Rank` FROM `Officers` AS `o` ) AS `u` -ORDER BY `u`.`SquadId`, `u`.`Nickname` +"""); + } + + public override async Task ToString_nullable_enum_property_projection(bool async) + { + await base.ToString_nullable_enum_property_projection(async); + + AssertSql( +""" +SELECT CASE `w`.`AmmunitionType` + WHEN 1 THEN 'Cartridge' + WHEN 2 THEN 'Shell' + ELSE COALESCE(CAST(`w`.`AmmunitionType` AS char), '') +END +FROM `Weapons` AS `w` +"""); + } + + public override async Task ToString_enum_contains(bool async) + { + await base.ToString_enum_contains(async); + + AssertSql( +""" +SELECT `m`.`CodeName` +FROM `Missions` AS `m` +WHERE CAST(`m`.`Difficulty` AS char) LIKE '%Med%' +"""); + } + + public override async Task ToString_nullable_enum_contains(bool async) + { + await base.ToString_nullable_enum_contains(async); + + AssertSql( +""" +SELECT `w`.`Name` +FROM `Weapons` AS `w` +WHERE CASE `w`.`AmmunitionType` + WHEN 1 THEN 'Cartridge' + WHEN 2 THEN 'Shell' + ELSE COALESCE(CAST(`w`.`AmmunitionType` AS char), '') +END LIKE '%Cart%' """); } @@ -6904,7 +6952,7 @@ INNER JOIN ( FROM `LocustHordes` AS `l1` WHERE `l1`.`Name` = 'Swarm' ) AS `l2` ON `u`.`Name` = `l2`.`CommanderName` -WHERE (`l2`.`Eradicated` <> TRUE) OR (`l2`.`Eradicated` IS NULL) +WHERE (`l2`.`Eradicated` = FALSE) OR (`l2`.`Eradicated` IS NULL) """); } @@ -6927,7 +6975,7 @@ LEFT JOIN ( FROM `LocustHordes` AS `l1` WHERE `l1`.`Name` = 'Swarm' ) AS `l2` ON `u`.`Name` = `l2`.`CommanderName` -WHERE (`l2`.`Eradicated` <> TRUE) OR (`l2`.`Eradicated` IS NULL) +WHERE (`l2`.`Eradicated` = FALSE) OR (`l2`.`Eradicated` IS NULL) """); } @@ -7922,7 +7970,7 @@ SELECT COALESCE(( FROM `Weapons` AS `w` WHERE `u`.`FullName` = `w`.`OwnerFullName` ORDER BY `w`.`Id` - LIMIT 1), 0, 42) + LIMIT 1), 0) FROM ( SELECT `g`.`FullName` FROM `Gears` AS `g` @@ -8689,7 +8737,6 @@ public override async Task OrderBy_same_expression_containing_IsNull_correctly_d """ SELECT CASE WHEN `u`.`LeaderNickname` IS NOT NULL THEN CHAR_LENGTH(`u`.`Nickname`) = 5 - ELSE NULL END FROM ( SELECT `g`.`Nickname`, `g`.`LeaderNickname` @@ -8700,7 +8747,6 @@ UNION ALL ) AS `u` ORDER BY CASE WHEN `u`.`LeaderNickname` IS NOT NULL THEN CHAR_LENGTH(`u`.`Nickname`) = 5 - ELSE NULL END IS NOT NULL """); } @@ -8736,7 +8782,7 @@ public override async Task GetValueOrDefault_in_filter_non_nullable_column(bool """ SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` FROM `Weapons` AS `w` -WHERE COALESCE(`w`.`Id`, 0) = 0 +WHERE `w`.`Id` = 0 """); } @@ -9621,7 +9667,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` - WHERE (`u`.`Nickname` <> @__prm_Inner_Nickname_0) AND (`u`.`Nickname` <> @__prm_Inner_Nickname_0) + WHERE `u`.`Nickname` <> @__prm_Inner_Nickname_0 ) AS `u0` ORDER BY `u0`.`FullName` """); @@ -9904,16 +9950,19 @@ public override async Task Group_by_with_having_StartsWith_with_null_parameter_a AssertSql( """ -SELECT `u`.`FullName` +SELECT `u0`.`FullName` FROM ( - SELECT `g`.`FullName` - FROM `Gears` AS `g` - UNION ALL - SELECT `o`.`FullName` - FROM `Officers` AS `o` -) AS `u` -GROUP BY `u`.`FullName` -HAVING FALSE + SELECT `u`.`FullName`, FALSE AS `c` + FROM ( + SELECT `g`.`FullName` + FROM `Gears` AS `g` + UNION ALL + SELECT `o`.`FullName` + FROM `Officers` AS `o` + ) AS `u` + GROUP BY `u`.`FullName`, `c` + HAVING `c` +) AS `u0` """); } @@ -10048,7 +10097,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & @__rank_0) = @__rank_0 +WHERE CAST(`u`.`Rank` & @__rank_0 AS signed) = @__rank_0 """, // """ @@ -10073,7 +10122,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` | @__rank_0) <> @__rank_0 +WHERE CAST(`u`.`Rank` | @__rank_0 AS signed) <> @__rank_0 """, // """ @@ -10146,13 +10195,13 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (`u`.`Rank` & @__ranks_0) <> 0 +WHERE CAST(`u`.`Rank` & @__ranks_0 AS signed) <> 0 """, // """ @__ranks_0='134' -SELECT (`u`.`Rank` | @__ranks_0) = @__ranks_0 +SELECT CAST(`u`.`Rank` | @__ranks_0 AS signed) = @__ranks_0 FROM ( SELECT `g`.`Rank` FROM `Gears` AS `g` @@ -10165,7 +10214,7 @@ UNION ALL """ @__ranks_0='134' -SELECT (`u`.`Rank` | (`u`.`Rank` | (@__ranks_0 | (`u`.`Rank` | @__ranks_0)))) = @__ranks_0 +SELECT CAST(`u`.`Rank` | CAST(`u`.`Rank` | CAST(@__ranks_0 | CAST(`u`.`Rank` | @__ranks_0 AS signed) AS signed) AS signed) AS signed) = @__ranks_0 FROM ( SELECT `g`.`Rank` FROM `Gears` AS `g` @@ -10209,7 +10258,7 @@ public override async Task Bitwise_operation_with_null_arguments(bool async) SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` FROM `Weapons` AS `w` -WHERE ((`w`.`AmmunitionType` & @__prm_0) <> 0) OR `w`.`AmmunitionType` IS NULL +WHERE (CAST(`w`.`AmmunitionType` & @__prm_0 AS signed) <> 0) OR `w`.`AmmunitionType` IS NULL """, // """ @@ -10217,7 +10266,7 @@ public override async Task Bitwise_operation_with_null_arguments(bool async) SELECT `w`.`Id`, `w`.`AmmunitionType`, `w`.`IsAutomatic`, `w`.`Name`, `w`.`OwnerFullName`, `w`.`SynergyWithId` FROM `Weapons` AS `w` -WHERE (`w`.`AmmunitionType` & @__prm_0) = @__prm_0 +WHERE CAST(`w`.`AmmunitionType` & @__prm_0 AS signed) = @__prm_0 """); } @@ -10274,7 +10323,6 @@ public override async Task Join_inner_source_custom_projection_followed_by_filte """ SELECT CASE WHEN `l1`.`Name` = 'Locust' THEN TRUE - ELSE NULL END AS `IsEradicated`, `l1`.`CommanderName`, `l1`.`Name` FROM ( SELECT `l`.`Name` @@ -10286,10 +10334,8 @@ UNION ALL INNER JOIN `LocustHordes` AS `l1` ON `u`.`Name` = `l1`.`CommanderName` WHERE (CASE WHEN `l1`.`Name` = 'Locust' THEN TRUE - ELSE NULL -END <> TRUE) OR (CASE +END = FALSE) OR (CASE WHEN `l1`.`Name` = 'Locust' THEN TRUE - ELSE NULL END IS NULL) """); } @@ -10413,15 +10459,11 @@ UNION ALL FROM `Officers` AS `o` ) AS `u` WHERE CASE - WHEN `u`.`HasSoulPatch` = @__prm_0 THEN (( - SELECT `w`.`Name` - FROM `Weapons` AS `w` - WHERE `w`.`Id` = `u`.`SquadId` - LIMIT 1) = @__prm2_1) AND ( + WHEN `u`.`HasSoulPatch` = @__prm_0 THEN ( SELECT `w`.`Name` FROM `Weapons` AS `w` WHERE `w`.`Id` = `u`.`SquadId` - LIMIT 1) IS NOT NULL + LIMIT 1) = @__prm2_1 ELSE FALSE END """); @@ -10448,7 +10490,7 @@ public override async Task DateTimeOffset_Date_returns_datetime(bool async) """ @__dateTimeOffset_Date_0='0002-03-01T00:00:00.0000000' (DbType = DateTime) -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE CONVERT(`m`.`Timeline`, date) >= @__dateTimeOffset_Date_0 """); @@ -10632,7 +10674,7 @@ public override async Task Where_TimeSpan_Hours(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(hour FROM `m`.`Duration`) = 1 """); @@ -10644,7 +10686,7 @@ public override async Task Where_TimeSpan_Minutes(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(minute FROM `m`.`Duration`) = 2 """); @@ -10656,7 +10698,7 @@ public override async Task Where_TimeSpan_Seconds(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(second FROM `m`.`Duration`) = 3 """); @@ -10668,7 +10710,7 @@ public override async Task Where_TimeSpan_Milliseconds(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE (EXTRACT(microsecond FROM `m`.`Duration`)) DIV (1000) = 456 """); @@ -10972,7 +11014,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (@__prm_0 & `u`.`Rank`) = `u`.`Rank` +WHERE CAST(@__prm_0 & `u`.`Rank` AS signed) = `u`.`Rank` """); } @@ -10992,7 +11034,7 @@ UNION ALL SELECT `o`.`Nickname`, `o`.`SquadId`, `o`.`AssignedCityName`, `o`.`CityOfBirthName`, `o`.`FullName`, `o`.`HasSoulPatch`, `o`.`LeaderNickname`, `o`.`LeaderSquadId`, `o`.`Rank`, 'Officer' AS `Discriminator` FROM `Officers` AS `o` ) AS `u` -WHERE (@__prm_0 & CAST(`u`.`Rank` AS signed)) = CAST(`u`.`Rank` AS signed) +WHERE CAST(@__prm_0 & CAST(`u`.`Rank` AS signed) AS signed) = CAST(`u`.`Rank` AS signed) """); } @@ -11004,7 +11046,7 @@ public override async Task Constant_enum_with_same_underlying_value_as_previousl """ @__p_0='1' -SELECT `u`.`Rank` & 1 +SELECT CAST(`u`.`Rank` & 1 AS signed) FROM ( SELECT `g`.`Nickname`, `g`.`Rank` FROM `Gears` AS `g` @@ -11536,7 +11578,6 @@ UNION ALL ) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) WHERE CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END = 1 """); } @@ -11558,7 +11599,6 @@ UNION ALL ) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) WHERE (CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END + 1) = 2 """); } @@ -11571,7 +11611,6 @@ public override async Task Projecting_property_converted_to_nullable_with_additi """ SELECT `t`.`Note`, CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END + 1 AS `Value` FROM `Tags` AS `t` LEFT JOIN ( @@ -11583,7 +11622,6 @@ UNION ALL ) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) WHERE CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`Nickname` - ELSE NULL END IS NOT NULL """); } @@ -11597,7 +11635,6 @@ public override async Task Projecting_property_converted_to_nullable_with_condit SELECT CASE WHEN (`t`.`Note` <> 'K.I.A.') OR `t`.`Note` IS NULL THEN CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END ELSE -1 END @@ -11620,7 +11657,6 @@ public override async Task Projecting_property_converted_to_nullable_with_functi """ SELECT SUBSTRING(CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`Nickname` - ELSE NULL END, 0 + 1, 3) FROM `Tags` AS `t` LEFT JOIN ( @@ -11641,7 +11677,6 @@ public override async Task Projecting_property_converted_to_nullable_with_functi """ SELECT `t`.`Note`, SUBSTRING(`t`.`Note`, 0 + 1, CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END) AS `Function` FROM `Tags` AS `t` LEFT JOIN ( @@ -11653,7 +11688,6 @@ UNION ALL ) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) WHERE CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`Nickname` - ELSE NULL END IS NOT NULL """); } @@ -11666,13 +11700,10 @@ public override async Task Projecting_property_converted_to_nullable_into_elemen """ SELECT CASE WHEN `t`.`GearNickName` IS NOT NULL THEN CHAR_LENGTH(`u`.`Nickname`) - ELSE NULL END, CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END, CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END + 1 FROM `Tags` AS `t` LEFT JOIN ( @@ -11684,7 +11715,6 @@ UNION ALL ) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) WHERE CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`Nickname` - ELSE NULL END IS NOT NULL ORDER BY `t`.`Note` """); @@ -11698,7 +11728,6 @@ public override async Task Projecting_property_converted_to_nullable_into_member """ SELECT CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END AS `Id` FROM `Tags` AS `t` LEFT JOIN ( @@ -11710,7 +11739,6 @@ UNION ALL ) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) WHERE CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`Nickname` - ELSE NULL END IS NOT NULL ORDER BY `t`.`Note` """); @@ -11724,13 +11752,10 @@ public override async Task Projecting_property_converted_to_nullable_into_new_ar """ SELECT CASE WHEN `t`.`GearNickName` IS NOT NULL THEN CHAR_LENGTH(`u`.`Nickname`) - ELSE NULL END, CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END, CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END + 1 FROM `Tags` AS `t` LEFT JOIN ( @@ -11742,7 +11767,6 @@ UNION ALL ) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) WHERE CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`Nickname` - ELSE NULL END IS NOT NULL ORDER BY `t`.`Note` """); @@ -11765,10 +11789,8 @@ UNION ALL ) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) WHERE CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`Nickname` - ELSE NULL END IS NOT NULL AND NOT (CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`HasSoulPatch` - ELSE NULL END) ORDER BY `t`.`Note` """); @@ -11811,11 +11833,9 @@ UNION ALL ) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) WHERE CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`Nickname` - ELSE NULL END IS NOT NULL ORDER BY CASE WHEN `t`.`GearNickName` IS NOT NULL THEN `u`.`SquadId` - ELSE NULL END, `t`.`Note` """); } @@ -11826,7 +11846,7 @@ public override async Task Where_DateOnly_Year(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(year FROM `m`.`Date`) = 1990 """); @@ -11838,7 +11858,7 @@ public override async Task Where_DateOnly_Month(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(month FROM `m`.`Date`) = 11 """); @@ -11850,7 +11870,7 @@ public override async Task Where_DateOnly_Day(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(day FROM `m`.`Date`) = 10 """); @@ -11862,7 +11882,7 @@ public override async Task Where_DateOnly_DayOfYear(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE DAYOFYEAR(`m`.`Date`) = 314 """); @@ -11874,7 +11894,7 @@ public override async Task Where_DateOnly_DayOfWeek(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE (DAYOFWEEK(`m`.`Date`) - 1) = 6 """); @@ -11886,7 +11906,7 @@ public override async Task Where_DateOnly_AddYears(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE DATE_ADD(`m`.`Date`, INTERVAL CAST(3 AS signed) year) = DATE '1993-11-10' """); @@ -11898,7 +11918,7 @@ public override async Task Where_DateOnly_AddMonths(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE DATE_ADD(`m`.`Date`, INTERVAL CAST(3 AS signed) month) = DATE '1991-02-10' """); @@ -11910,7 +11930,7 @@ public override async Task Where_DateOnly_AddDays(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE DATE_ADD(`m`.`Date`, INTERVAL CAST(3 AS signed) day) = DATE '1990-11-13' """); @@ -11922,7 +11942,7 @@ public override async Task Where_TimeOnly_Hour(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(hour FROM `m`.`Time`) = 10 """); @@ -11934,7 +11954,7 @@ public override async Task Where_TimeOnly_Minute(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(minute FROM `m`.`Time`) = 15 """); @@ -11946,7 +11966,7 @@ public override async Task Where_TimeOnly_Second(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE EXTRACT(second FROM `m`.`Time`) = 50 """); @@ -11958,7 +11978,7 @@ public override async Task Where_TimeOnly_Millisecond(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE (EXTRACT(microsecond FROM `m`.`Time`)) DIV (1000) = 500 """); @@ -11970,7 +11990,7 @@ public override async Task Where_TimeOnly_AddHours(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE DATE_ADD(`m`.`Time`, INTERVAL CAST(3.0 AS signed) hour) = TIME '13:15:50.5' """); @@ -11982,7 +12002,7 @@ public override async Task Where_TimeOnly_AddMinutes(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE DATE_ADD(`m`.`Time`, INTERVAL CAST(3.0 AS signed) minute) = TIME '10:18:50.5' """); @@ -11994,7 +12014,7 @@ public override async Task Where_TimeOnly_Add_TimeSpan(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE (`m`.`Time` + TIME '03:00:00') = TIME '13:15:50.5' """); @@ -12006,7 +12026,7 @@ public override async Task Where_TimeOnly_IsBetween(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE (`m`.`Time` >= TIME '10:00:00') & (`m`.`Time` < TIME '11:00:00') """); @@ -12018,7 +12038,7 @@ public override async Task Where_TimeOnly_subtract_TimeOnly(bool async) AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE (`m`.`Time` - TIME '10:00:00') = TIME '00:15:50.5' """); @@ -12216,7 +12236,7 @@ public override async Task Enum_matching_take_value_gets_different_type_mapping( @__value_1='1' @__p_0='1' -SELECT `u`.`Rank` & @__value_1 +SELECT CAST(`u`.`Rank` & @__value_1 AS signed) FROM ( SELECT `g`.`Nickname`, `g`.`Rank` FROM `Gears` AS `g` @@ -12591,7 +12611,7 @@ public override async Task Where_equals_method_on_nullable_with_object_overload( AssertSql( """ -SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` FROM `Missions` AS `m` WHERE `m`.`Rating` IS NULL """); @@ -12710,10 +12730,10 @@ public override async Task ToString_boolean_property_nullable(bool async) AssertSql( """ -SELECT CASE - WHEN `l`.`Eradicated` = FALSE THEN 'False' - WHEN `l`.`Eradicated` = TRUE THEN 'True' - ELSE NULL +SELECT CASE `l`.`Eradicated` + WHEN FALSE THEN 'False' + WHEN TRUE THEN 'True' + ELSE '' END FROM `LocustHordes` AS `l` """); @@ -12760,8 +12780,8 @@ public override async Task ToString_boolean_property_non_nullable(bool async) AssertSql( """ SELECT CASE - WHEN `w`.`IsAutomatic` = FALSE THEN 'False' - ELSE 'True' + WHEN `w`.`IsAutomatic` = TRUE THEN 'True' + ELSE 'False' END FROM `Weapons` AS `w` """); @@ -13814,6 +13834,150 @@ public override async Task Nested_contains_with_enum(bool async) AssertSql(""); } + public override async Task ToString_boolean_computed_nullable(bool async) + { + await base.ToString_boolean_computed_nullable(async); + + AssertSql( +""" +SELECT CASE (`l`.`Eradicated` = TRUE) OR ((`l`.`CommanderName` = 'Unknown') AND `l`.`CommanderName` IS NOT NULL) + WHEN FALSE THEN 'False' + WHEN TRUE THEN 'True' + ELSE '' +END +FROM `LocustHordes` AS `l` +"""); + } + + public override async Task Select_inverted_nullable_boolean(bool async) + { + await base.Select_inverted_nullable_boolean(async); + + AssertSql( +""" +SELECT `l`.`Id`, `l`.`Eradicated` = FALSE AS `Alive` +FROM `LocustHordes` AS `l` +"""); + } + + public override async Task Where_TimeOnly_FromDateTime_compared_to_property(bool async) + { + await base.Where_TimeOnly_FromDateTime_compared_to_property(async); + + AssertSql( +""" +SELECT `t`.`Id` AS `TagId`, `m`.`Id` AS `MissionId` +FROM `Tags` AS `t` +CROSS JOIN `Missions` AS `m` +WHERE TIME(`t`.`IssueDate`) = `m`.`Time` +"""); + } + + public override async Task Where_TimeOnly_FromDateTime_compared_to_parameter(bool async) + { + await base.Where_TimeOnly_FromDateTime_compared_to_parameter(async); + + AssertSql( +""" +@__time_0='02:00' (DbType = Time) + +SELECT `t`.`Id`, `t`.`GearNickName`, `t`.`GearSquadId`, `t`.`IssueDate`, `t`.`Note` +FROM `Tags` AS `t` +LEFT JOIN ( + SELECT `g`.`Nickname`, `g`.`SquadId` + FROM `Gears` AS `g` + UNION ALL + SELECT `o`.`Nickname`, `o`.`SquadId` + FROM `Officers` AS `o` +) AS `u` ON (`t`.`GearNickName` = `u`.`Nickname`) AND (`t`.`GearSquadId` = `u`.`SquadId`) +WHERE (`u`.`Nickname` IS NOT NULL AND (`u`.`SquadId` IS NOT NULL)) AND (TIME(DATE_ADD(`t`.`IssueDate`, INTERVAL CAST(CAST(`u`.`SquadId` AS double) AS signed) hour)) = @__time_0) +"""); + } + + public override async Task Where_TimeOnly_FromDateTime_compared_to_constant(bool async) + { + await base.Where_TimeOnly_FromDateTime_compared_to_constant(async); + + AssertSql( +""" +SELECT `t`.`Id`, `t`.`GearNickName`, `t`.`GearSquadId`, `t`.`IssueDate`, `t`.`Note` +FROM `Tags` AS `t` +WHERE TIME(DATE_ADD(`t`.`IssueDate`, INTERVAL CAST(CAST(CHAR_LENGTH(`t`.`Note`) AS double) AS signed) hour)) > TIME '09:00:00' +"""); + } + + public override async Task Where_TimeOnly_FromTimeSpan_compared_to_property(bool async) + { + await base.Where_TimeOnly_FromTimeSpan_compared_to_property(async); + + AssertSql( +""" +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +FROM `Missions` AS `m` +WHERE `m`.`Duration` < `m`.`Time` +"""); + } + + public override async Task Where_TimeOnly_FromTimeSpan_compared_to_parameter(bool async) + { + await base.Where_TimeOnly_FromTimeSpan_compared_to_parameter(async); + + AssertSql( +""" +@__time_0='01:02' (DbType = Time) + +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +FROM `Missions` AS `m` +WHERE `m`.`Duration` = @__time_0 +"""); + } + + public override async Task Order_by_TimeOnly_FromTimeSpan(bool async) + { + await base.Order_by_TimeOnly_FromTimeSpan(async); + + AssertSql( +""" +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +FROM `Missions` AS `m` +ORDER BY `m`.`Duration` +"""); + } + + public override async Task Where_DateOnly_FromDateTime_compared_to_property(bool async) + { + await base.Where_DateOnly_FromDateTime_compared_to_property(async); + + AssertSql( +""" +SELECT `t`.`Id` AS `TagId`, `m`.`Id` AS `MissionId` +FROM `Tags` AS `t` +CROSS JOIN `Missions` AS `m` +WHERE DATE(`t`.`IssueDate`) > `m`.`Date` +"""); + } + + public override async Task Where_DateOnly_FromDateTime_compared_to_constant_and_parameter(bool async) + { + await base.Where_DateOnly_FromDateTime_compared_to_constant_and_parameter(async); + + AssertSql( +""" +@__prm_0='10/11/0002' (DbType = Date) + +SELECT `t`.`Id`, `t`.`GearNickName`, `t`.`GearSquadId`, `t`.`IssueDate`, `t`.`Note` +FROM `Tags` AS `t` +WHERE DATE(`t`.`IssueDate`) IN (@__prm_0, DATE '0015-03-07') +"""); + } + + // TODO: Implement once TimeSpan is translated as ticks instead of TIME. + public override async Task Non_string_concat_uses_appropriate_type_mapping(bool async) + { + var exception = await Assert.ThrowsAsync(() => base.Non_string_concat_uses_appropriate_type_mapping(async)); + Assert.Equal("Unable to cast object of type 'System.Decimal' to type 'System.TimeSpan'.", exception.Message); + } + private void AssertSql(params string[] expected) => Fixture.TestSqlLoggerFactory.AssertBaseline(expected); } diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPCManyToManyNoTrackingQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPCManyToManyNoTrackingQueryMySqlTest.cs index b9c3f443c..6da3c74f3 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPCManyToManyNoTrackingQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPCManyToManyNoTrackingQueryMySqlTest.cs @@ -16,12 +16,9 @@ public TPCManyToManyNoTrackingQueryMySqlTest(TPCManyToManyQueryMySqlFixture fixt //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Skip_navigation_all(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPCManyToManyQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPCManyToManyQueryMySqlTest.cs index 75f9a10b7..6af24c76f 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPCManyToManyQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPCManyToManyQueryMySqlTest.cs @@ -16,12 +16,9 @@ public TPCManyToManyQueryMySqlTest(TPCManyToManyQueryMySqlFixture fixture, ITest //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Skip_navigation_all(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPCRelationshipsQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPCRelationshipsQueryMySqlTest.cs index 4f432af2a..cbf81e21f 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPCRelationshipsQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPCRelationshipsQueryMySqlTest.cs @@ -21,7 +21,7 @@ public TPCRelationshipsQueryMySqlTest( [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override void Changes_in_derived_related_entities_are_detected() { diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPTGearsOfWarQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPTGearsOfWarQueryMySqlTest.cs index cc1cfebd9..a0a91e103 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPTGearsOfWarQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPTGearsOfWarQueryMySqlTest.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Linq; using System.Linq.Expressions; using System.Threading.Tasks; @@ -23,9 +23,6 @@ public TPTGearsOfWarQueryMySqlTest(TPTGearsOfWarQueryMySqlFixture fixture, ITest //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - protected override bool CanExecuteQueryString - => true; - public override Task DateTimeOffset_Contains_Less_than_Greater_than(bool async) { var dto = MySqlTestHelpers.GetExpectedValue(new DateTimeOffset(599898024001234567, new TimeSpan(1, 30, 0))); @@ -304,12 +301,19 @@ await AssertQuery( where m.Timeline.Hour == /* 10 */ 8 select m); - AssertSql( - """ - SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` - FROM `Missions` AS `m` - WHERE EXTRACT(hour FROM `m`.`Timeline`) = 8 - """); + AssertSql( +""" +SELECT `m`.`Id`, `m`.`CodeName`, `m`.`Date`, `m`.`Difficulty`, `m`.`Duration`, `m`.`Rating`, `m`.`Time`, `m`.`Timeline` +FROM `Missions` AS `m` +WHERE EXTRACT(hour FROM `m`.`Timeline`) = 8 +"""); + } + + // TODO: Implement once TimeSpan is translated as ticks instead of TIME. + public override async Task Non_string_concat_uses_appropriate_type_mapping(bool async) + { + var exception = await Assert.ThrowsAsync(() => base.Non_string_concat_uses_appropriate_type_mapping(async)); + Assert.Equal("Unable to cast object of type 'System.Decimal' to type 'System.TimeSpan'.", exception.Message); } private string AssertSql(string expected) diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPTManyToManyNoTrackingQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPTManyToManyNoTrackingQueryMySqlTest.cs index c43cc52d5..4ac5ae27c 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPTManyToManyNoTrackingQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPTManyToManyNoTrackingQueryMySqlTest.cs @@ -11,8 +11,5 @@ public TPTManyToManyNoTrackingQueryMySqlTest(TPTManyToManyQueryMySqlFixture fixt Fixture.TestSqlLoggerFactory.Clear(); //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - - protected override bool CanExecuteQueryString - => true; } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/TPTManyToManyQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/TPTManyToManyQueryMySqlTest.cs index 4fd2cee8a..d9b767b55 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/TPTManyToManyQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/TPTManyToManyQueryMySqlTest.cs @@ -11,8 +11,5 @@ public TPTManyToManyQueryMySqlTest(TPTManyToManyQueryMySqlFixture fixture, ITest Fixture.TestSqlLoggerFactory.Clear(); //Fixture.TestSqlLoggerFactory.SetTestOutputHelper(testOutputHelper); } - - protected override bool CanExecuteQueryString - => true; } } diff --git a/test/EFCore.MySql.FunctionalTests/Query/ToSqlQueryMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Query/ToSqlQueryMySqlTest.cs index 6f0e1108e..2b4d6f375 100644 --- a/test/EFCore.MySql.FunctionalTests/Query/ToSqlQueryMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Query/ToSqlQueryMySqlTest.cs @@ -13,7 +13,7 @@ protected override ITestStoreFactory TestStoreFactory [ConditionalFact] public virtual void Check_all_tests_overridden() - => TestHelpers.AssertAllMethodsOverridden(GetType()); + => MySqlTestHelpers.AssertAllMethodsOverridden(GetType()); public override async Task Entity_type_with_navigation_mapped_to_SqlQuery(bool async) { diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DataEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DataEntityType.cs index 0a3766e7a..ba9746b04 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DataEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DataEntityType.cs @@ -1,10 +1,14 @@ // using System; using System.Collections; +using System.Collections.Generic; using System.Linq; using System.Reflection; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.Storage.Json; @@ -17,7 +21,8 @@ namespace TestNamespace { - internal partial class DataEntityType + [EntityFrameworkInternal] + public partial class DataEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -34,19 +39,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueGenerated: ValueGenerated.OnAdd, afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: 0); + id.SetAccessors( + int (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(0) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(0) && entry.ReadShadowValue(0) == 0 ? entry.ReadTemporaryValue(0) : entry.ReadShadowValue(0))), + int (InternalEntityEntry entry) => entry.ReadShadowValue(0), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 0), + int (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + id.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: 0, + relationshipIndex: 0, + storeGenerationIndex: 0); id.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); + id.SetCurrentValueComparer(new EntryCurrentValueComparer(id)); id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); var blob = runtimeEntityType.AddProperty( @@ -55,25 +73,58 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.Data).GetProperty("Blob", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.Data).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + blob.SetGetter( + byte[] (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity), + bool (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity) == null, + byte[] (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance), + bool (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance) == null); + blob.SetSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetMaterializationSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetAccessors( + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(blob, 1), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(blob), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + blob.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); blob.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray())); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray())); blob.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var point = runtimeEntityType.AddProperty( "Point", typeof(Point), nullable: true); + point.SetAccessors( + Point (InternalEntityEntry entry) => entry.ReadShadowValue(1), + Point (InternalEntityEntry entry) => entry.ReadShadowValue(1), + Point (InternalEntityEntry entry) => entry.ReadOriginalValue(point, 2), + Point (InternalEntityEntry entry) => entry.GetCurrentValue(point), + object (ValueBuffer valueBuffer) => valueBuffer[2]); + point.SetPropertyIndexes( + index: 2, + originalValueIndex: 2, + shadowIndex: 1, + relationshipIndex: -1, + storeGenerationIndex: -1); point.TypeMapping = null; point.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -85,30 +136,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueConverter: new CastingConverter(), valueComparer: new CompiledModelTestBase.CustomValueComparer(), providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + stringWithCharSet.SetAccessors( + string (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(3) ? entry.ReadStoreGeneratedValue(1) : (entry.FlaggedAsTemporary(3) && entry.ReadShadowValue(2) == null ? entry.ReadTemporaryValue(1) : entry.ReadShadowValue(2))), + string (InternalEntityEntry entry) => entry.ReadShadowValue(2), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringWithCharSet, 3), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringWithCharSet), + object (ValueBuffer valueBuffer) => valueBuffer[3]); + stringWithCharSet.SetPropertyIndexes( + index: 3, + originalValueIndex: 3, + shadowIndex: 2, + relationshipIndex: -1, + storeGenerationIndex: 1); stringWithCharSet.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(128)", size: 128), converter: new ValueConverter( - (string v) => (string)v, - (string v) => (string)v), + string (string v) => ((string)(v)), + string (string v) => ((string)(v))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (string v) => (string)v, - (string v) => (string)v))); + string (string v) => ((string)(v)), + string (string v) => ((string)(v))))); stringWithCharSet.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); stringWithCharSet.AddAnnotation("Relational:ColumnType", "varchar(128)"); stringWithCharSet.AddAnnotation("Relational:DefaultValue", "String having charset"); @@ -121,30 +184,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueConverter: new CastingConverter(), valueComparer: new CompiledModelTestBase.CustomValueComparer(), providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + stringWithCollation.SetAccessors( + string (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(4) ? entry.ReadStoreGeneratedValue(2) : (entry.FlaggedAsTemporary(4) && entry.ReadShadowValue(3) == null ? entry.ReadTemporaryValue(2) : entry.ReadShadowValue(3))), + string (InternalEntityEntry entry) => entry.ReadShadowValue(3), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringWithCollation, 4), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringWithCollation), + object (ValueBuffer valueBuffer) => valueBuffer[4]); + stringWithCollation.SetPropertyIndexes( + index: 4, + originalValueIndex: 4, + shadowIndex: 3, + relationshipIndex: -1, + storeGenerationIndex: 2); stringWithCollation.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(128)", size: 128), converter: new ValueConverter( - (string v) => (string)v, - (string v) => (string)v), + string (string v) => ((string)(v)), + string (string v) => ((string)(v))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (string v) => (string)v, - (string v) => (string)v))); + string (string v) => ((string)(v)), + string (string v) => ((string)(v))))); stringWithCollation.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); stringWithCollation.AddAnnotation("Relational:ColumnType", "varchar(128)"); stringWithCollation.AddAnnotation("Relational:DefaultValue", "String using collation"); @@ -158,6 +233,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var id = runtimeEntityType.FindProperty("Id"); + var blob = runtimeEntityType.FindProperty("Blob"); + var point = runtimeEntityType.FindProperty("Point"); + var stringWithCharSet = runtimeEntityType.FindProperty("StringWithCharSet"); + var stringWithCollation = runtimeEntityType.FindProperty("StringWithCollation"); + var key = runtimeEntityType.FindKey(new[] { id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateSimpleNonNullableFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory(key)); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.Data)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id)), (source.GetCurrentValue(blob) == null ? null : ((ValueComparer)(((IProperty)blob).GetValueComparer())).Snapshot(source.GetCurrentValue(blob))), (source.GetCurrentValue(point) == null ? null : ((ValueComparer)(((IProperty)point).GetValueComparer())).Snapshot(source.GetCurrentValue(point))), (source.GetCurrentValue(stringWithCharSet) == null ? null : ((ValueComparer)(((IProperty)stringWithCharSet).GetValueComparer())).Snapshot(source.GetCurrentValue(stringWithCharSet))), (source.GetCurrentValue(stringWithCollation) == null ? null : ((ValueComparer)(((IProperty)stringWithCollation).GetValueComparer())).Snapshot(source.GetCurrentValue(stringWithCollation)))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(default(int)), (default(string) == null ? null : ((ValueComparer)(((IProperty)stringWithCharSet).GetValueComparer())).Snapshot(default(string))), (default(string) == null ? null : ((ValueComparer)(((IProperty)stringWithCollation).GetValueComparer())).Snapshot(default(string))))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(int), default(string), default(string))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("Id") ? ((int)(source["Id"])) : 0), (source.ContainsKey("Point") ? ((Point)(source["Point"])) : null), (source.ContainsKey("StringWithCharSet") ? ((string)(source["StringWithCharSet"])) : null), (source.ContainsKey("StringWithCollation") ? ((string)(source["StringWithCollation"])) : null))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(int), default(Point), default(string), default(string))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.Data)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 5, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 5, + shadowCount: 4, + relationshipCount: 1, + storeGeneratedCount: 3); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DataUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DataUnsafeAccessors.cs new file mode 100644 index 000000000..193c89702 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DataUnsafeAccessors.cs @@ -0,0 +1,16 @@ +// +using System; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DataUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[] Blob(CompiledModelTestBase.Data @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DbContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DbContextAssemblyAttributes.cs new file mode 100644 index 000000000..c224873f6 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DbContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(DbContext), typeof(DbContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DbContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DbContextModelBuilder.cs index 3892a94f3..95e39d60d 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DbContextModelBuilder.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DbContextModelBuilder.cs @@ -6,6 +6,8 @@ using Microsoft.EntityFrameworkCore.Metadata; using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Migrations; +using Microsoft.EntityFrameworkCore.Update.Internal; +using NetTopologySuite.Geometries; #pragma warning disable 219, 612, 618 #nullable disable @@ -55,7 +57,7 @@ partial void Initialize() AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); AddAnnotation("Relational:MaxIdentifierLength", 64); - AddRuntimeAnnotation("Relational:RelationalModel", CreateRelationalModel()); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); } private IRelationalModel CreateRelationalModel() @@ -104,34 +106,31 @@ private IRelationalModel CreateRelationalModel() var dataTable = new Table("Data", null, relationalModel); var idColumn = new Column("Id", "int", dataTable); dataTable.Columns.Add("Id", idColumn); + idColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn); var blobColumn = new Column("Blob", "longblob", dataTable) { IsNullable = true }; dataTable.Columns.Add("Blob", blobColumn); + blobColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(blobColumn); var pointColumn = new Column("Point", "point", dataTable) { IsNullable = true }; dataTable.Columns.Add("Point", pointColumn); + pointColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(pointColumn); var stringWithCharSetColumn = new Column("StringWithCharSet", "varchar(128)", dataTable) { IsNullable = true }; dataTable.Columns.Add("StringWithCharSet", stringWithCharSetColumn); + stringWithCharSetColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringWithCharSetColumn); var stringWithCollationColumn = new Column("StringWithCollation", "varchar(128)", dataTable) { IsNullable = true }; dataTable.Columns.Add("StringWithCollation", stringWithCollationColumn); - var pK_Data = new UniqueConstraint("PK_Data", dataTable, new[] { idColumn }); - dataTable.PrimaryKey = pK_Data; - var pK_DataUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", - new[] { "Id" }); - pK_Data.MappedKeys.Add(pK_DataUc); - RelationalModel.GetOrCreateUniqueConstraints(pK_DataUc).Add(pK_Data); - dataTable.UniqueConstraints.Add("PK_Data", pK_Data); + stringWithCollationColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringWithCollationColumn); relationalModel.Tables.Add(("Data", null), dataTable); var dataTableMapping = new TableMapping(data, dataTable, null); dataTable.AddTypeMapping(dataTableMapping, false); @@ -141,6 +140,15 @@ private IRelationalModel CreateRelationalModel() RelationalModel.CreateColumnMapping(pointColumn, data.FindProperty("Point")!, dataTableMapping); RelationalModel.CreateColumnMapping(stringWithCharSetColumn, data.FindProperty("StringWithCharSet")!, dataTableMapping); RelationalModel.CreateColumnMapping(stringWithCollationColumn, data.FindProperty("StringWithCollation")!, dataTableMapping); + var pK_Data = new UniqueConstraint("PK_Data", dataTable, new[] { idColumn }); + dataTable.PrimaryKey = pK_Data; + pK_Data.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(pK_Data)); + var pK_DataKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", + new[] { "Id" }); + pK_Data.MappedKeys.Add(pK_DataKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_DataKey).Add(pK_Data); + dataTable.UniqueConstraints.Add("PK_Data", pK_Data); var dependentBase = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase")!; @@ -182,41 +190,31 @@ private IRelationalModel CreateRelationalModel() var dependentBasebyteTable = new Table("DependentBase", null, relationalModel); var principalIdColumn = new Column("PrincipalId", "bigint", dependentBasebyteTable); dependentBasebyteTable.Columns.Add("PrincipalId", principalIdColumn); + principalIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalIdColumn); var principalAlternateIdColumn = new Column("PrincipalAlternateId", "char(36)", dependentBasebyteTable); dependentBasebyteTable.Columns.Add("PrincipalAlternateId", principalAlternateIdColumn); + principalAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalAlternateIdColumn); var dataColumn = new Column("Data", "char(20)", dependentBasebyteTable) { IsNullable = true }; dependentBasebyteTable.Columns.Add("Data", dataColumn); + dataColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dataColumn); var enumDiscriminatorColumn = new Column("EnumDiscriminator", "int", dependentBasebyteTable); dependentBasebyteTable.Columns.Add("EnumDiscriminator", enumDiscriminatorColumn); + enumDiscriminatorColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumDiscriminatorColumn); var idColumn0 = new Column("Id", "tinyint unsigned", dependentBasebyteTable) { IsNullable = true }; dependentBasebyteTable.Columns.Add("Id", idColumn0); + idColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn0); var moneyColumn = new Column("Money", "decimal(9,3)", dependentBasebyteTable) { IsNullable = true }; dependentBasebyteTable.Columns.Add("Money", moneyColumn); - var pK_DependentBasebyte = new UniqueConstraint("PK_DependentBase", dependentBasebyteTable, new[] { principalIdColumn, principalAlternateIdColumn }); - dependentBasebyteTable.PrimaryKey = pK_DependentBasebyte; - var pK_DependentBasebyteUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", - new[] { "PrincipalId", "PrincipalAlternateId" }); - pK_DependentBasebyte.MappedKeys.Add(pK_DependentBasebyteUc); - RelationalModel.GetOrCreateUniqueConstraints(pK_DependentBasebyteUc).Add(pK_DependentBasebyte); - dependentBasebyteTable.UniqueConstraints.Add("PK_DependentBase", pK_DependentBasebyte); - var iX_DependentBasebyte_PrincipalId = new TableIndex( - "IX_DependentBase_PrincipalId", dependentBasebyteTable, new[] { principalIdColumn }, true); - var iX_DependentBasebyte_PrincipalIdIx = RelationalModel.GetIndex(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", - new[] { "PrincipalId" }); - iX_DependentBasebyte_PrincipalId.MappedIndexes.Add(iX_DependentBasebyte_PrincipalIdIx); - RelationalModel.GetOrCreateTableIndexes(iX_DependentBasebyte_PrincipalIdIx).Add(iX_DependentBasebyte_PrincipalId); - dependentBasebyteTable.Indexes.Add("IX_DependentBase_PrincipalId", iX_DependentBasebyte_PrincipalId); + moneyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(moneyColumn); relationalModel.Tables.Add(("DependentBase", null), dependentBasebyteTable); var dependentBasebyteTableMapping = new TableMapping(dependentBase, dependentBasebyteTable, true) { @@ -257,6 +255,24 @@ private IRelationalModel CreateRelationalModel() RelationalModel.CreateColumnMapping(enumDiscriminatorColumn, dependentDerived.FindProperty("EnumDiscriminator")!, dependentBasebyteTableMapping0); RelationalModel.CreateColumnMapping(idColumn0, dependentDerived.FindProperty("Id")!, dependentBasebyteTableMapping0); RelationalModel.CreateColumnMapping(moneyColumn, dependentDerived.FindProperty("Money")!, dependentBasebyteTableMapping0); + var pK_DependentBasebyte = new UniqueConstraint("PK_DependentBase", dependentBasebyteTable, new[] { principalIdColumn, principalAlternateIdColumn }); + dependentBasebyteTable.PrimaryKey = pK_DependentBasebyte; + pK_DependentBasebyte.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK_DependentBasebyte)); + var pK_DependentBasebyteKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", + new[] { "PrincipalId", "PrincipalAlternateId" }); + pK_DependentBasebyte.MappedKeys.Add(pK_DependentBasebyteKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_DependentBasebyteKey).Add(pK_DependentBasebyte); + dependentBasebyteTable.UniqueConstraints.Add("PK_DependentBase", pK_DependentBasebyte); + var iX_DependentBasebyte_PrincipalId = new TableIndex( + "IX_DependentBase_PrincipalId", dependentBasebyteTable, new[] { principalIdColumn }, true); + iX_DependentBasebyte_PrincipalId.SetRowIndexValueFactory(new SimpleRowIndexValueFactory(iX_DependentBasebyte_PrincipalId)); + var iX_DependentBasebyte_PrincipalIdIx = RelationalModel.GetIndex(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", + new[] { "PrincipalId" }); + iX_DependentBasebyte_PrincipalId.MappedIndexes.Add(iX_DependentBasebyte_PrincipalIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_DependentBasebyte_PrincipalIdIx).Add(iX_DependentBasebyte_PrincipalId); + dependentBasebyteTable.Indexes.Add("IX_DependentBase_PrincipalId", iX_DependentBasebyte_PrincipalId); var manyTypes = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+ManyTypes")!; @@ -1104,607 +1120,835 @@ private IRelationalModel CreateRelationalModel() var manyTypesTable = new Table("ManyTypes", null, relationalModel); var idColumn1 = new Column("Id", "int", manyTypesTable); manyTypesTable.Columns.Add("Id", idColumn1); + idColumn1.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn1); var boolColumn = new Column("Bool", "tinyint(1)", manyTypesTable); manyTypesTable.Columns.Add("Bool", boolColumn); + boolColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(boolColumn); var boolArrayColumn = new Column("BoolArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("BoolArray", boolArrayColumn); + boolArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(boolArrayColumn); var boolToStringConverterPropertyColumn = new Column("BoolToStringConverterProperty", "varchar(1)", manyTypesTable); manyTypesTable.Columns.Add("BoolToStringConverterProperty", boolToStringConverterPropertyColumn); + boolToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(boolToStringConverterPropertyColumn); var boolToTwoValuesConverterPropertyColumn = new Column("BoolToTwoValuesConverterProperty", "tinyint unsigned", manyTypesTable); manyTypesTable.Columns.Add("BoolToTwoValuesConverterProperty", boolToTwoValuesConverterPropertyColumn); + boolToTwoValuesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(boolToTwoValuesConverterPropertyColumn); var boolToZeroOneConverterPropertyColumn = new Column("BoolToZeroOneConverterProperty", "smallint", manyTypesTable); manyTypesTable.Columns.Add("BoolToZeroOneConverterProperty", boolToZeroOneConverterPropertyColumn); + boolToZeroOneConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(boolToZeroOneConverterPropertyColumn); var bytesColumn = new Column("Bytes", "longblob", manyTypesTable); manyTypesTable.Columns.Add("Bytes", bytesColumn); + bytesColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(bytesColumn); var bytesArrayColumn = new Column("BytesArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("BytesArray", bytesArrayColumn); + bytesArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(bytesArrayColumn); var bytesToStringConverterPropertyColumn = new Column("BytesToStringConverterProperty", "longtext", manyTypesTable); manyTypesTable.Columns.Add("BytesToStringConverterProperty", bytesToStringConverterPropertyColumn); + bytesToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(bytesToStringConverterPropertyColumn); var castingConverterPropertyColumn = new Column("CastingConverterProperty", "decimal(65,30)", manyTypesTable); manyTypesTable.Columns.Add("CastingConverterProperty", castingConverterPropertyColumn); + castingConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(castingConverterPropertyColumn); var charColumn = new Column("Char", "varchar(1)", manyTypesTable); manyTypesTable.Columns.Add("Char", charColumn); + charColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(charColumn); var charArrayColumn = new Column("CharArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("CharArray", charArrayColumn); + charArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(charArrayColumn); var charToStringConverterPropertyColumn = new Column("CharToStringConverterProperty", "varchar(1)", manyTypesTable); manyTypesTable.Columns.Add("CharToStringConverterProperty", charToStringConverterPropertyColumn); + charToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(charToStringConverterPropertyColumn); var dateOnlyColumn = new Column("DateOnly", "date", manyTypesTable); manyTypesTable.Columns.Add("DateOnly", dateOnlyColumn); + dateOnlyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateOnlyColumn); var dateOnlyArrayColumn = new Column("DateOnlyArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("DateOnlyArray", dateOnlyArrayColumn); + dateOnlyArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateOnlyArrayColumn); var dateOnlyToStringConverterPropertyColumn = new Column("DateOnlyToStringConverterProperty", "varchar(10)", manyTypesTable); manyTypesTable.Columns.Add("DateOnlyToStringConverterProperty", dateOnlyToStringConverterPropertyColumn); + dateOnlyToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateOnlyToStringConverterPropertyColumn); var dateTimeColumn = new Column("DateTime", "datetime(6)", manyTypesTable); manyTypesTable.Columns.Add("DateTime", dateTimeColumn); + dateTimeColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateTimeColumn); var dateTimeArrayColumn = new Column("DateTimeArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("DateTimeArray", dateTimeArrayColumn); + dateTimeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateTimeArrayColumn); var dateTimeOffsetToBinaryConverterPropertyColumn = new Column("DateTimeOffsetToBinaryConverterProperty", "bigint", manyTypesTable); manyTypesTable.Columns.Add("DateTimeOffsetToBinaryConverterProperty", dateTimeOffsetToBinaryConverterPropertyColumn); + dateTimeOffsetToBinaryConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateTimeOffsetToBinaryConverterPropertyColumn); var dateTimeOffsetToBytesConverterPropertyColumn = new Column("DateTimeOffsetToBytesConverterProperty", "varbinary(12)", manyTypesTable); manyTypesTable.Columns.Add("DateTimeOffsetToBytesConverterProperty", dateTimeOffsetToBytesConverterPropertyColumn); + dateTimeOffsetToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateTimeOffsetToBytesConverterPropertyColumn); var dateTimeOffsetToStringConverterPropertyColumn = new Column("DateTimeOffsetToStringConverterProperty", "varchar(48)", manyTypesTable); manyTypesTable.Columns.Add("DateTimeOffsetToStringConverterProperty", dateTimeOffsetToStringConverterPropertyColumn); + dateTimeOffsetToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateTimeOffsetToStringConverterPropertyColumn); var dateTimeToBinaryConverterPropertyColumn = new Column("DateTimeToBinaryConverterProperty", "bigint", manyTypesTable); manyTypesTable.Columns.Add("DateTimeToBinaryConverterProperty", dateTimeToBinaryConverterPropertyColumn); + dateTimeToBinaryConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateTimeToBinaryConverterPropertyColumn); var dateTimeToStringConverterPropertyColumn = new Column("DateTimeToStringConverterProperty", "varchar(48)", manyTypesTable); manyTypesTable.Columns.Add("DateTimeToStringConverterProperty", dateTimeToStringConverterPropertyColumn); + dateTimeToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateTimeToStringConverterPropertyColumn); var dateTimeToTicksConverterPropertyColumn = new Column("DateTimeToTicksConverterProperty", "datetime(6)", manyTypesTable); manyTypesTable.Columns.Add("DateTimeToTicksConverterProperty", dateTimeToTicksConverterPropertyColumn); + dateTimeToTicksConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dateTimeToTicksConverterPropertyColumn); var decimalColumn = new Column("Decimal", "decimal(65,30)", manyTypesTable); manyTypesTable.Columns.Add("Decimal", decimalColumn); + decimalColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(decimalColumn); var decimalArrayColumn = new Column("DecimalArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("DecimalArray", decimalArrayColumn); + decimalArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(decimalArrayColumn); var decimalNumberToBytesConverterPropertyColumn = new Column("DecimalNumberToBytesConverterProperty", "varbinary(16)", manyTypesTable); manyTypesTable.Columns.Add("DecimalNumberToBytesConverterProperty", decimalNumberToBytesConverterPropertyColumn); + decimalNumberToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(decimalNumberToBytesConverterPropertyColumn); var decimalNumberToStringConverterPropertyColumn = new Column("DecimalNumberToStringConverterProperty", "varchar(64)", manyTypesTable); manyTypesTable.Columns.Add("DecimalNumberToStringConverterProperty", decimalNumberToStringConverterPropertyColumn); + decimalNumberToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(decimalNumberToStringConverterPropertyColumn); var doubleColumn = new Column("Double", "double", manyTypesTable); manyTypesTable.Columns.Add("Double", doubleColumn); + doubleColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(doubleColumn); var doubleArrayColumn = new Column("DoubleArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("DoubleArray", doubleArrayColumn); + doubleArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(doubleArrayColumn); var doubleNumberToBytesConverterPropertyColumn = new Column("DoubleNumberToBytesConverterProperty", "varbinary(8)", manyTypesTable); manyTypesTable.Columns.Add("DoubleNumberToBytesConverterProperty", doubleNumberToBytesConverterPropertyColumn); + doubleNumberToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(doubleNumberToBytesConverterPropertyColumn); var doubleNumberToStringConverterPropertyColumn = new Column("DoubleNumberToStringConverterProperty", "varchar(64)", manyTypesTable); manyTypesTable.Columns.Add("DoubleNumberToStringConverterProperty", doubleNumberToStringConverterPropertyColumn); + doubleNumberToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(doubleNumberToStringConverterPropertyColumn); var enum16Column = new Column("Enum16", "smallint", manyTypesTable); manyTypesTable.Columns.Add("Enum16", enum16Column); + enum16Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enum16Column); var enum16ArrayColumn = new Column("Enum16Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum16Array", enum16ArrayColumn); + enum16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum16ArrayColumn); var enum16AsStringColumn = new Column("Enum16AsString", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum16AsString", enum16AsStringColumn); + enum16AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum16AsStringColumn); var enum16AsStringArrayColumn = new Column("Enum16AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum16AsStringArray", enum16AsStringArrayColumn); + enum16AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum16AsStringArrayColumn); var enum16AsStringCollectionColumn = new Column("Enum16AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum16AsStringCollection", enum16AsStringCollectionColumn); + enum16AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum16AsStringCollectionColumn); var enum16CollectionColumn = new Column("Enum16Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum16Collection", enum16CollectionColumn); + enum16CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum16CollectionColumn); var enum32Column = new Column("Enum32", "int", manyTypesTable); manyTypesTable.Columns.Add("Enum32", enum32Column); + enum32Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enum32Column); var enum32ArrayColumn = new Column("Enum32Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum32Array", enum32ArrayColumn); + enum32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum32ArrayColumn); var enum32AsStringColumn = new Column("Enum32AsString", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum32AsString", enum32AsStringColumn); + enum32AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum32AsStringColumn); var enum32AsStringArrayColumn = new Column("Enum32AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum32AsStringArray", enum32AsStringArrayColumn); + enum32AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum32AsStringArrayColumn); var enum32AsStringCollectionColumn = new Column("Enum32AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum32AsStringCollection", enum32AsStringCollectionColumn); + enum32AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum32AsStringCollectionColumn); var enum32CollectionColumn = new Column("Enum32Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum32Collection", enum32CollectionColumn); + enum32CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum32CollectionColumn); var enum64Column = new Column("Enum64", "bigint", manyTypesTable); manyTypesTable.Columns.Add("Enum64", enum64Column); + enum64Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enum64Column); var enum64ArrayColumn = new Column("Enum64Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum64Array", enum64ArrayColumn); + enum64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum64ArrayColumn); var enum64AsStringColumn = new Column("Enum64AsString", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum64AsString", enum64AsStringColumn); + enum64AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum64AsStringColumn); var enum64AsStringArrayColumn = new Column("Enum64AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum64AsStringArray", enum64AsStringArrayColumn); + enum64AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum64AsStringArrayColumn); var enum64AsStringCollectionColumn = new Column("Enum64AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum64AsStringCollection", enum64AsStringCollectionColumn); + enum64AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum64AsStringCollectionColumn); var enum64CollectionColumn = new Column("Enum64Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum64Collection", enum64CollectionColumn); + enum64CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum64CollectionColumn); var enum8Column = new Column("Enum8", "tinyint", manyTypesTable); manyTypesTable.Columns.Add("Enum8", enum8Column); + enum8Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enum8Column); var enum8ArrayColumn = new Column("Enum8Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum8Array", enum8ArrayColumn); + enum8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum8ArrayColumn); var enum8AsStringColumn = new Column("Enum8AsString", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum8AsString", enum8AsStringColumn); + enum8AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum8AsStringColumn); var enum8AsStringArrayColumn = new Column("Enum8AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum8AsStringArray", enum8AsStringArrayColumn); + enum8AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum8AsStringArrayColumn); var enum8AsStringCollectionColumn = new Column("Enum8AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum8AsStringCollection", enum8AsStringCollectionColumn); + enum8AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum8AsStringCollectionColumn); var enum8CollectionColumn = new Column("Enum8Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Enum8Collection", enum8CollectionColumn); + enum8CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enum8CollectionColumn); var enumToNumberConverterPropertyColumn = new Column("EnumToNumberConverterProperty", "int", manyTypesTable); manyTypesTable.Columns.Add("EnumToNumberConverterProperty", enumToNumberConverterPropertyColumn); + enumToNumberConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumToNumberConverterPropertyColumn); var enumToStringConverterPropertyColumn = new Column("EnumToStringConverterProperty", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumToStringConverterProperty", enumToStringConverterPropertyColumn); + enumToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumToStringConverterPropertyColumn); var enumU16Column = new Column("EnumU16", "smallint unsigned", manyTypesTable); manyTypesTable.Columns.Add("EnumU16", enumU16Column); + enumU16Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU16Column); var enumU16ArrayColumn = new Column("EnumU16Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU16Array", enumU16ArrayColumn); + enumU16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU16ArrayColumn); var enumU16AsStringColumn = new Column("EnumU16AsString", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU16AsString", enumU16AsStringColumn); + enumU16AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU16AsStringColumn); var enumU16AsStringArrayColumn = new Column("EnumU16AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU16AsStringArray", enumU16AsStringArrayColumn); + enumU16AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU16AsStringArrayColumn); var enumU16AsStringCollectionColumn = new Column("EnumU16AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU16AsStringCollection", enumU16AsStringCollectionColumn); + enumU16AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU16AsStringCollectionColumn); var enumU16CollectionColumn = new Column("EnumU16Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU16Collection", enumU16CollectionColumn); + enumU16CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU16CollectionColumn); var enumU32Column = new Column("EnumU32", "int unsigned", manyTypesTable); manyTypesTable.Columns.Add("EnumU32", enumU32Column); + enumU32Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU32Column); var enumU32ArrayColumn = new Column("EnumU32Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU32Array", enumU32ArrayColumn); + enumU32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU32ArrayColumn); var enumU32AsStringColumn = new Column("EnumU32AsString", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU32AsString", enumU32AsStringColumn); + enumU32AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU32AsStringColumn); var enumU32AsStringArrayColumn = new Column("EnumU32AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU32AsStringArray", enumU32AsStringArrayColumn); + enumU32AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU32AsStringArrayColumn); var enumU32AsStringCollectionColumn = new Column("EnumU32AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU32AsStringCollection", enumU32AsStringCollectionColumn); + enumU32AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU32AsStringCollectionColumn); var enumU32CollectionColumn = new Column("EnumU32Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU32Collection", enumU32CollectionColumn); + enumU32CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU32CollectionColumn); var enumU64Column = new Column("EnumU64", "bigint unsigned", manyTypesTable); manyTypesTable.Columns.Add("EnumU64", enumU64Column); + enumU64Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU64Column); var enumU64ArrayColumn = new Column("EnumU64Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU64Array", enumU64ArrayColumn); + enumU64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU64ArrayColumn); var enumU64AsStringColumn = new Column("EnumU64AsString", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU64AsString", enumU64AsStringColumn); + enumU64AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU64AsStringColumn); var enumU64AsStringArrayColumn = new Column("EnumU64AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU64AsStringArray", enumU64AsStringArrayColumn); + enumU64AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU64AsStringArrayColumn); var enumU64AsStringCollectionColumn = new Column("EnumU64AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU64AsStringCollection", enumU64AsStringCollectionColumn); + enumU64AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU64AsStringCollectionColumn); var enumU64CollectionColumn = new Column("EnumU64Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU64Collection", enumU64CollectionColumn); + enumU64CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU64CollectionColumn); var enumU8Column = new Column("EnumU8", "tinyint unsigned", manyTypesTable); manyTypesTable.Columns.Add("EnumU8", enumU8Column); + enumU8Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU8Column); var enumU8ArrayColumn = new Column("EnumU8Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU8Array", enumU8ArrayColumn); + enumU8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU8ArrayColumn); var enumU8AsStringColumn = new Column("EnumU8AsString", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU8AsString", enumU8AsStringColumn); + enumU8AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU8AsStringColumn); var enumU8AsStringArrayColumn = new Column("EnumU8AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU8AsStringArray", enumU8AsStringArrayColumn); + enumU8AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU8AsStringArrayColumn); var enumU8AsStringCollectionColumn = new Column("EnumU8AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU8AsStringCollection", enumU8AsStringCollectionColumn); + enumU8AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU8AsStringCollectionColumn); var enumU8CollectionColumn = new Column("EnumU8Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("EnumU8Collection", enumU8CollectionColumn); + enumU8CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(enumU8CollectionColumn); var floatColumn = new Column("Float", "float", manyTypesTable); manyTypesTable.Columns.Add("Float", floatColumn); + floatColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(floatColumn); var floatArrayColumn = new Column("FloatArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("FloatArray", floatArrayColumn); + floatArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(floatArrayColumn); var guidColumn = new Column("Guid", "char(36)", manyTypesTable); manyTypesTable.Columns.Add("Guid", guidColumn); + guidColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(guidColumn); var guidArrayColumn = new Column("GuidArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("GuidArray", guidArrayColumn); + guidArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(guidArrayColumn); var guidToBytesConverterPropertyColumn = new Column("GuidToBytesConverterProperty", "varbinary(16)", manyTypesTable); manyTypesTable.Columns.Add("GuidToBytesConverterProperty", guidToBytesConverterPropertyColumn); + guidToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(guidToBytesConverterPropertyColumn); var guidToStringConverterPropertyColumn = new Column("GuidToStringConverterProperty", "varchar(36)", manyTypesTable); manyTypesTable.Columns.Add("GuidToStringConverterProperty", guidToStringConverterPropertyColumn); + guidToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(guidToStringConverterPropertyColumn); var iPAddressColumn = new Column("IPAddress", "varchar(45)", manyTypesTable); manyTypesTable.Columns.Add("IPAddress", iPAddressColumn); + iPAddressColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(iPAddressColumn); var iPAddressArrayColumn = new Column("IPAddressArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("IPAddressArray", iPAddressArrayColumn); + iPAddressArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(iPAddressArrayColumn); var iPAddressToBytesConverterPropertyColumn = new Column("IPAddressToBytesConverterProperty", "varbinary(16)", manyTypesTable); manyTypesTable.Columns.Add("IPAddressToBytesConverterProperty", iPAddressToBytesConverterPropertyColumn); + iPAddressToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(iPAddressToBytesConverterPropertyColumn); var iPAddressToStringConverterPropertyColumn = new Column("IPAddressToStringConverterProperty", "varchar(45)", manyTypesTable); manyTypesTable.Columns.Add("IPAddressToStringConverterProperty", iPAddressToStringConverterPropertyColumn); + iPAddressToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(iPAddressToStringConverterPropertyColumn); var int16Column = new Column("Int16", "smallint", manyTypesTable); manyTypesTable.Columns.Add("Int16", int16Column); + int16Column.Accessors = ColumnAccessorsFactory.CreateGeneric(int16Column); var int16ArrayColumn = new Column("Int16Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Int16Array", int16ArrayColumn); + int16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(int16ArrayColumn); var int32Column = new Column("Int32", "int", manyTypesTable); manyTypesTable.Columns.Add("Int32", int32Column); + int32Column.Accessors = ColumnAccessorsFactory.CreateGeneric(int32Column); var int32ArrayColumn = new Column("Int32Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Int32Array", int32ArrayColumn); + int32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(int32ArrayColumn); var int64Column = new Column("Int64", "bigint", manyTypesTable); manyTypesTable.Columns.Add("Int64", int64Column); + int64Column.Accessors = ColumnAccessorsFactory.CreateGeneric(int64Column); var int64ArrayColumn = new Column("Int64Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Int64Array", int64ArrayColumn); + int64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(int64ArrayColumn); var int8Column = new Column("Int8", "tinyint", manyTypesTable); manyTypesTable.Columns.Add("Int8", int8Column); + int8Column.Accessors = ColumnAccessorsFactory.CreateGeneric(int8Column); var int8ArrayColumn = new Column("Int8Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Int8Array", int8ArrayColumn); + int8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(int8ArrayColumn); var intNumberToBytesConverterPropertyColumn = new Column("IntNumberToBytesConverterProperty", "varbinary(4)", manyTypesTable); manyTypesTable.Columns.Add("IntNumberToBytesConverterProperty", intNumberToBytesConverterPropertyColumn); + intNumberToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(intNumberToBytesConverterPropertyColumn); var intNumberToStringConverterPropertyColumn = new Column("IntNumberToStringConverterProperty", "varchar(64)", manyTypesTable); manyTypesTable.Columns.Add("IntNumberToStringConverterProperty", intNumberToStringConverterPropertyColumn); + intNumberToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(intNumberToStringConverterPropertyColumn); var nullIntToNullStringConverterPropertyColumn = new Column("NullIntToNullStringConverterProperty", "longtext", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullIntToNullStringConverterProperty", nullIntToNullStringConverterPropertyColumn); + nullIntToNullStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullIntToNullStringConverterPropertyColumn); var nullableBoolColumn = new Column("NullableBool", "tinyint(1)", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableBool", nullableBoolColumn); + nullableBoolColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableBoolColumn); var nullableBoolArrayColumn = new Column("NullableBoolArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableBoolArray", nullableBoolArrayColumn); + nullableBoolArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableBoolArrayColumn); var nullableBytesColumn = new Column("NullableBytes", "longblob", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableBytes", nullableBytesColumn); + nullableBytesColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableBytesColumn); var nullableBytesArrayColumn = new Column("NullableBytesArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableBytesArray", nullableBytesArrayColumn); + nullableBytesArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableBytesArrayColumn); var nullableCharColumn = new Column("NullableChar", "varchar(1)", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableChar", nullableCharColumn); + nullableCharColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableCharColumn); var nullableCharArrayColumn = new Column("NullableCharArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableCharArray", nullableCharArrayColumn); + nullableCharArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableCharArrayColumn); var nullableDateOnlyColumn = new Column("NullableDateOnly", "date", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableDateOnly", nullableDateOnlyColumn); + nullableDateOnlyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableDateOnlyColumn); var nullableDateOnlyArrayColumn = new Column("NullableDateOnlyArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableDateOnlyArray", nullableDateOnlyArrayColumn); + nullableDateOnlyArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableDateOnlyArrayColumn); var nullableDateTimeColumn = new Column("NullableDateTime", "datetime(6)", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableDateTime", nullableDateTimeColumn); + nullableDateTimeColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableDateTimeColumn); var nullableDateTimeArrayColumn = new Column("NullableDateTimeArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableDateTimeArray", nullableDateTimeArrayColumn); + nullableDateTimeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableDateTimeArrayColumn); var nullableDecimalColumn = new Column("NullableDecimal", "decimal(65,30)", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableDecimal", nullableDecimalColumn); + nullableDecimalColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableDecimalColumn); var nullableDecimalArrayColumn = new Column("NullableDecimalArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableDecimalArray", nullableDecimalArrayColumn); + nullableDecimalArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableDecimalArrayColumn); var nullableDoubleColumn = new Column("NullableDouble", "double", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableDouble", nullableDoubleColumn); + nullableDoubleColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableDoubleColumn); var nullableDoubleArrayColumn = new Column("NullableDoubleArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableDoubleArray", nullableDoubleArrayColumn); + nullableDoubleArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableDoubleArrayColumn); var nullableEnum16Column = new Column("NullableEnum16", "smallint", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnum16", nullableEnum16Column); + nullableEnum16Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum16Column); var nullableEnum16ArrayColumn = new Column("NullableEnum16Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum16Array", nullableEnum16ArrayColumn); + nullableEnum16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum16ArrayColumn); var nullableEnum16AsStringColumn = new Column("NullableEnum16AsString", "smallint", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnum16AsString", nullableEnum16AsStringColumn); + nullableEnum16AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum16AsStringColumn); var nullableEnum16AsStringArrayColumn = new Column("NullableEnum16AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum16AsStringArray", nullableEnum16AsStringArrayColumn); + nullableEnum16AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum16AsStringArrayColumn); var nullableEnum16AsStringCollectionColumn = new Column("NullableEnum16AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum16AsStringCollection", nullableEnum16AsStringCollectionColumn); + nullableEnum16AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum16AsStringCollectionColumn); var nullableEnum16CollectionColumn = new Column("NullableEnum16Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum16Collection", nullableEnum16CollectionColumn); + nullableEnum16CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum16CollectionColumn); var nullableEnum32Column = new Column("NullableEnum32", "int", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnum32", nullableEnum32Column); + nullableEnum32Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum32Column); var nullableEnum32ArrayColumn = new Column("NullableEnum32Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum32Array", nullableEnum32ArrayColumn); + nullableEnum32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum32ArrayColumn); var nullableEnum32AsStringColumn = new Column("NullableEnum32AsString", "int", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnum32AsString", nullableEnum32AsStringColumn); + nullableEnum32AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum32AsStringColumn); var nullableEnum32AsStringArrayColumn = new Column("NullableEnum32AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum32AsStringArray", nullableEnum32AsStringArrayColumn); + nullableEnum32AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum32AsStringArrayColumn); var nullableEnum32AsStringCollectionColumn = new Column("NullableEnum32AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum32AsStringCollection", nullableEnum32AsStringCollectionColumn); + nullableEnum32AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum32AsStringCollectionColumn); var nullableEnum32CollectionColumn = new Column("NullableEnum32Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum32Collection", nullableEnum32CollectionColumn); + nullableEnum32CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum32CollectionColumn); var nullableEnum64Column = new Column("NullableEnum64", "bigint", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnum64", nullableEnum64Column); + nullableEnum64Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum64Column); var nullableEnum64ArrayColumn = new Column("NullableEnum64Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum64Array", nullableEnum64ArrayColumn); + nullableEnum64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum64ArrayColumn); var nullableEnum64AsStringColumn = new Column("NullableEnum64AsString", "bigint", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnum64AsString", nullableEnum64AsStringColumn); + nullableEnum64AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum64AsStringColumn); var nullableEnum64AsStringArrayColumn = new Column("NullableEnum64AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum64AsStringArray", nullableEnum64AsStringArrayColumn); + nullableEnum64AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum64AsStringArrayColumn); var nullableEnum64AsStringCollectionColumn = new Column("NullableEnum64AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum64AsStringCollection", nullableEnum64AsStringCollectionColumn); + nullableEnum64AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum64AsStringCollectionColumn); var nullableEnum64CollectionColumn = new Column("NullableEnum64Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum64Collection", nullableEnum64CollectionColumn); + nullableEnum64CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum64CollectionColumn); var nullableEnum8Column = new Column("NullableEnum8", "tinyint", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnum8", nullableEnum8Column); + nullableEnum8Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum8Column); var nullableEnum8ArrayColumn = new Column("NullableEnum8Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum8Array", nullableEnum8ArrayColumn); + nullableEnum8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum8ArrayColumn); var nullableEnum8AsStringColumn = new Column("NullableEnum8AsString", "tinyint", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnum8AsString", nullableEnum8AsStringColumn); + nullableEnum8AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum8AsStringColumn); var nullableEnum8AsStringArrayColumn = new Column("NullableEnum8AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum8AsStringArray", nullableEnum8AsStringArrayColumn); + nullableEnum8AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum8AsStringArrayColumn); var nullableEnum8AsStringCollectionColumn = new Column("NullableEnum8AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum8AsStringCollection", nullableEnum8AsStringCollectionColumn); + nullableEnum8AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum8AsStringCollectionColumn); var nullableEnum8CollectionColumn = new Column("NullableEnum8Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnum8Collection", nullableEnum8CollectionColumn); + nullableEnum8CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnum8CollectionColumn); var nullableEnumU16Column = new Column("NullableEnumU16", "smallint unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnumU16", nullableEnumU16Column); + nullableEnumU16Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU16Column); var nullableEnumU16ArrayColumn = new Column("NullableEnumU16Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU16Array", nullableEnumU16ArrayColumn); + nullableEnumU16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU16ArrayColumn); var nullableEnumU16AsStringColumn = new Column("NullableEnumU16AsString", "smallint unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnumU16AsString", nullableEnumU16AsStringColumn); + nullableEnumU16AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU16AsStringColumn); var nullableEnumU16AsStringArrayColumn = new Column("NullableEnumU16AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU16AsStringArray", nullableEnumU16AsStringArrayColumn); + nullableEnumU16AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU16AsStringArrayColumn); var nullableEnumU16AsStringCollectionColumn = new Column("NullableEnumU16AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU16AsStringCollection", nullableEnumU16AsStringCollectionColumn); + nullableEnumU16AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU16AsStringCollectionColumn); var nullableEnumU16CollectionColumn = new Column("NullableEnumU16Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU16Collection", nullableEnumU16CollectionColumn); + nullableEnumU16CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU16CollectionColumn); var nullableEnumU32Column = new Column("NullableEnumU32", "int unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnumU32", nullableEnumU32Column); + nullableEnumU32Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU32Column); var nullableEnumU32ArrayColumn = new Column("NullableEnumU32Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU32Array", nullableEnumU32ArrayColumn); + nullableEnumU32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU32ArrayColumn); var nullableEnumU32AsStringColumn = new Column("NullableEnumU32AsString", "int unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnumU32AsString", nullableEnumU32AsStringColumn); + nullableEnumU32AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU32AsStringColumn); var nullableEnumU32AsStringArrayColumn = new Column("NullableEnumU32AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU32AsStringArray", nullableEnumU32AsStringArrayColumn); + nullableEnumU32AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU32AsStringArrayColumn); var nullableEnumU32AsStringCollectionColumn = new Column("NullableEnumU32AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU32AsStringCollection", nullableEnumU32AsStringCollectionColumn); + nullableEnumU32AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU32AsStringCollectionColumn); var nullableEnumU32CollectionColumn = new Column("NullableEnumU32Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU32Collection", nullableEnumU32CollectionColumn); + nullableEnumU32CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU32CollectionColumn); var nullableEnumU64Column = new Column("NullableEnumU64", "bigint unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnumU64", nullableEnumU64Column); + nullableEnumU64Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU64Column); var nullableEnumU64ArrayColumn = new Column("NullableEnumU64Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU64Array", nullableEnumU64ArrayColumn); + nullableEnumU64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU64ArrayColumn); var nullableEnumU64AsStringColumn = new Column("NullableEnumU64AsString", "bigint unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnumU64AsString", nullableEnumU64AsStringColumn); + nullableEnumU64AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU64AsStringColumn); var nullableEnumU64AsStringArrayColumn = new Column("NullableEnumU64AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU64AsStringArray", nullableEnumU64AsStringArrayColumn); + nullableEnumU64AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU64AsStringArrayColumn); var nullableEnumU64AsStringCollectionColumn = new Column("NullableEnumU64AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU64AsStringCollection", nullableEnumU64AsStringCollectionColumn); + nullableEnumU64AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU64AsStringCollectionColumn); var nullableEnumU64CollectionColumn = new Column("NullableEnumU64Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU64Collection", nullableEnumU64CollectionColumn); + nullableEnumU64CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU64CollectionColumn); var nullableEnumU8Column = new Column("NullableEnumU8", "tinyint unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnumU8", nullableEnumU8Column); + nullableEnumU8Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU8Column); var nullableEnumU8ArrayColumn = new Column("NullableEnumU8Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU8Array", nullableEnumU8ArrayColumn); + nullableEnumU8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU8ArrayColumn); var nullableEnumU8AsStringColumn = new Column("NullableEnumU8AsString", "tinyint unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableEnumU8AsString", nullableEnumU8AsStringColumn); + nullableEnumU8AsStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU8AsStringColumn); var nullableEnumU8AsStringArrayColumn = new Column("NullableEnumU8AsStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU8AsStringArray", nullableEnumU8AsStringArrayColumn); + nullableEnumU8AsStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU8AsStringArrayColumn); var nullableEnumU8AsStringCollectionColumn = new Column("NullableEnumU8AsStringCollection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU8AsStringCollection", nullableEnumU8AsStringCollectionColumn); + nullableEnumU8AsStringCollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU8AsStringCollectionColumn); var nullableEnumU8CollectionColumn = new Column("NullableEnumU8Collection", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableEnumU8Collection", nullableEnumU8CollectionColumn); + nullableEnumU8CollectionColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableEnumU8CollectionColumn); var nullableFloatColumn = new Column("NullableFloat", "float", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableFloat", nullableFloatColumn); + nullableFloatColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableFloatColumn); var nullableFloatArrayColumn = new Column("NullableFloatArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableFloatArray", nullableFloatArrayColumn); + nullableFloatArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableFloatArrayColumn); var nullableGuidColumn = new Column("NullableGuid", "char(36)", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableGuid", nullableGuidColumn); + nullableGuidColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableGuidColumn); var nullableGuidArrayColumn = new Column("NullableGuidArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableGuidArray", nullableGuidArrayColumn); + nullableGuidArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableGuidArrayColumn); var nullableIPAddressColumn = new Column("NullableIPAddress", "varchar(45)", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableIPAddress", nullableIPAddressColumn); + nullableIPAddressColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableIPAddressColumn); var nullableIPAddressArrayColumn = new Column("NullableIPAddressArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableIPAddressArray", nullableIPAddressArrayColumn); + nullableIPAddressArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableIPAddressArrayColumn); var nullableInt16Column = new Column("NullableInt16", "smallint", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableInt16", nullableInt16Column); + nullableInt16Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableInt16Column); var nullableInt16ArrayColumn = new Column("NullableInt16Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableInt16Array", nullableInt16ArrayColumn); + nullableInt16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableInt16ArrayColumn); var nullableInt32Column = new Column("NullableInt32", "int", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableInt32", nullableInt32Column); + nullableInt32Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableInt32Column); var nullableInt32ArrayColumn = new Column("NullableInt32Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableInt32Array", nullableInt32ArrayColumn); + nullableInt32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableInt32ArrayColumn); var nullableInt64Column = new Column("NullableInt64", "bigint", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableInt64", nullableInt64Column); + nullableInt64Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableInt64Column); var nullableInt64ArrayColumn = new Column("NullableInt64Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableInt64Array", nullableInt64ArrayColumn); + nullableInt64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableInt64ArrayColumn); var nullableInt8Column = new Column("NullableInt8", "tinyint", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableInt8", nullableInt8Column); + nullableInt8Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableInt8Column); var nullableInt8ArrayColumn = new Column("NullableInt8Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableInt8Array", nullableInt8ArrayColumn); + nullableInt8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableInt8ArrayColumn); var nullablePhysicalAddressColumn = new Column("NullablePhysicalAddress", "varchar(20)", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullablePhysicalAddress", nullablePhysicalAddressColumn); + nullablePhysicalAddressColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullablePhysicalAddressColumn); var nullablePhysicalAddressArrayColumn = new Column("NullablePhysicalAddressArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullablePhysicalAddressArray", nullablePhysicalAddressArrayColumn); + nullablePhysicalAddressArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullablePhysicalAddressArrayColumn); var nullableStringColumn = new Column("NullableString", "longtext", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableString", nullableStringColumn); + nullableStringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableStringColumn); var nullableStringArrayColumn = new Column("NullableStringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableStringArray", nullableStringArrayColumn); + nullableStringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableStringArrayColumn); var nullableTimeOnlyColumn = new Column("NullableTimeOnly", "time(6)", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableTimeOnly", nullableTimeOnlyColumn); + nullableTimeOnlyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableTimeOnlyColumn); var nullableTimeOnlyArrayColumn = new Column("NullableTimeOnlyArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableTimeOnlyArray", nullableTimeOnlyArrayColumn); + nullableTimeOnlyArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableTimeOnlyArrayColumn); var nullableTimeSpanColumn = new Column("NullableTimeSpan", "time(6)", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableTimeSpan", nullableTimeSpanColumn); + nullableTimeSpanColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableTimeSpanColumn); var nullableTimeSpanArrayColumn = new Column("NullableTimeSpanArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableTimeSpanArray", nullableTimeSpanArrayColumn); + nullableTimeSpanArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableTimeSpanArrayColumn); var nullableUInt16Column = new Column("NullableUInt16", "smallint unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableUInt16", nullableUInt16Column); + nullableUInt16Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUInt16Column); var nullableUInt16ArrayColumn = new Column("NullableUInt16Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableUInt16Array", nullableUInt16ArrayColumn); + nullableUInt16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUInt16ArrayColumn); var nullableUInt32Column = new Column("NullableUInt32", "int unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableUInt32", nullableUInt32Column); + nullableUInt32Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUInt32Column); var nullableUInt32ArrayColumn = new Column("NullableUInt32Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableUInt32Array", nullableUInt32ArrayColumn); + nullableUInt32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUInt32ArrayColumn); var nullableUInt64Column = new Column("NullableUInt64", "bigint unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableUInt64", nullableUInt64Column); + nullableUInt64Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUInt64Column); var nullableUInt64ArrayColumn = new Column("NullableUInt64Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableUInt64Array", nullableUInt64ArrayColumn); + nullableUInt64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUInt64ArrayColumn); var nullableUInt8Column = new Column("NullableUInt8", "tinyint unsigned", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableUInt8", nullableUInt8Column); + nullableUInt8Column.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUInt8Column); var nullableUInt8ArrayColumn = new Column("NullableUInt8Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableUInt8Array", nullableUInt8ArrayColumn); + nullableUInt8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUInt8ArrayColumn); var nullableUriColumn = new Column("NullableUri", "longtext", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("NullableUri", nullableUriColumn); + nullableUriColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUriColumn); var nullableUriArrayColumn = new Column("NullableUriArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("NullableUriArray", nullableUriArrayColumn); + nullableUriArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(nullableUriArrayColumn); var physicalAddressColumn = new Column("PhysicalAddress", "varchar(20)", manyTypesTable); manyTypesTable.Columns.Add("PhysicalAddress", physicalAddressColumn); + physicalAddressColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(physicalAddressColumn); var physicalAddressArrayColumn = new Column("PhysicalAddressArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("PhysicalAddressArray", physicalAddressArrayColumn); + physicalAddressArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(physicalAddressArrayColumn); var physicalAddressToBytesConverterPropertyColumn = new Column("PhysicalAddressToBytesConverterProperty", "varbinary(8)", manyTypesTable); manyTypesTable.Columns.Add("PhysicalAddressToBytesConverterProperty", physicalAddressToBytesConverterPropertyColumn); + physicalAddressToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(physicalAddressToBytesConverterPropertyColumn); var physicalAddressToStringConverterPropertyColumn = new Column("PhysicalAddressToStringConverterProperty", "varchar(20)", manyTypesTable); manyTypesTable.Columns.Add("PhysicalAddressToStringConverterProperty", physicalAddressToStringConverterPropertyColumn); + physicalAddressToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(physicalAddressToStringConverterPropertyColumn); var stringColumn = new Column("String", "longtext", manyTypesTable); manyTypesTable.Columns.Add("String", stringColumn); + stringColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringColumn); var stringArrayColumn = new Column("StringArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("StringArray", stringArrayColumn); + stringArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringArrayColumn); var stringToBoolConverterPropertyColumn = new Column("StringToBoolConverterProperty", "tinyint(1)", manyTypesTable); manyTypesTable.Columns.Add("StringToBoolConverterProperty", stringToBoolConverterPropertyColumn); + stringToBoolConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToBoolConverterPropertyColumn); var stringToBytesConverterPropertyColumn = new Column("StringToBytesConverterProperty", "longblob", manyTypesTable) { IsNullable = true }; manyTypesTable.Columns.Add("StringToBytesConverterProperty", stringToBytesConverterPropertyColumn); + stringToBytesConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToBytesConverterPropertyColumn); var stringToCharConverterPropertyColumn = new Column("StringToCharConverterProperty", "varchar(1)", manyTypesTable); manyTypesTable.Columns.Add("StringToCharConverterProperty", stringToCharConverterPropertyColumn); + stringToCharConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToCharConverterPropertyColumn); var stringToDateOnlyConverterPropertyColumn = new Column("StringToDateOnlyConverterProperty", "date", manyTypesTable); manyTypesTable.Columns.Add("StringToDateOnlyConverterProperty", stringToDateOnlyConverterPropertyColumn); + stringToDateOnlyConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToDateOnlyConverterPropertyColumn); var stringToDateTimeConverterPropertyColumn = new Column("StringToDateTimeConverterProperty", "datetime(6)", manyTypesTable); manyTypesTable.Columns.Add("StringToDateTimeConverterProperty", stringToDateTimeConverterPropertyColumn); + stringToDateTimeConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToDateTimeConverterPropertyColumn); var stringToDateTimeOffsetConverterPropertyColumn = new Column("StringToDateTimeOffsetConverterProperty", "datetime(6)", manyTypesTable); manyTypesTable.Columns.Add("StringToDateTimeOffsetConverterProperty", stringToDateTimeOffsetConverterPropertyColumn); + stringToDateTimeOffsetConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToDateTimeOffsetConverterPropertyColumn); var stringToDecimalNumberConverterPropertyColumn = new Column("StringToDecimalNumberConverterProperty", "decimal(65,30)", manyTypesTable); manyTypesTable.Columns.Add("StringToDecimalNumberConverterProperty", stringToDecimalNumberConverterPropertyColumn); + stringToDecimalNumberConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToDecimalNumberConverterPropertyColumn); var stringToDoubleNumberConverterPropertyColumn = new Column("StringToDoubleNumberConverterProperty", "double", manyTypesTable); manyTypesTable.Columns.Add("StringToDoubleNumberConverterProperty", stringToDoubleNumberConverterPropertyColumn); + stringToDoubleNumberConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToDoubleNumberConverterPropertyColumn); var stringToEnumConverterPropertyColumn = new Column("StringToEnumConverterProperty", "int unsigned", manyTypesTable); manyTypesTable.Columns.Add("StringToEnumConverterProperty", stringToEnumConverterPropertyColumn); + stringToEnumConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToEnumConverterPropertyColumn); var stringToGuidConverterPropertyColumn = new Column("StringToGuidConverterProperty", "longtext", manyTypesTable); manyTypesTable.Columns.Add("StringToGuidConverterProperty", stringToGuidConverterPropertyColumn); + stringToGuidConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToGuidConverterPropertyColumn); var stringToIntNumberConverterPropertyColumn = new Column("StringToIntNumberConverterProperty", "int", manyTypesTable); manyTypesTable.Columns.Add("StringToIntNumberConverterProperty", stringToIntNumberConverterPropertyColumn); + stringToIntNumberConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToIntNumberConverterPropertyColumn); var stringToTimeOnlyConverterPropertyColumn = new Column("StringToTimeOnlyConverterProperty", "time(6)", manyTypesTable); manyTypesTable.Columns.Add("StringToTimeOnlyConverterProperty", stringToTimeOnlyConverterPropertyColumn); + stringToTimeOnlyConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToTimeOnlyConverterPropertyColumn); var stringToTimeSpanConverterPropertyColumn = new Column("StringToTimeSpanConverterProperty", "time(6)", manyTypesTable); manyTypesTable.Columns.Add("StringToTimeSpanConverterProperty", stringToTimeSpanConverterPropertyColumn); + stringToTimeSpanConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToTimeSpanConverterPropertyColumn); var stringToUriConverterPropertyColumn = new Column("StringToUriConverterProperty", "longtext", manyTypesTable); manyTypesTable.Columns.Add("StringToUriConverterProperty", stringToUriConverterPropertyColumn); + stringToUriConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(stringToUriConverterPropertyColumn); var timeOnlyColumn = new Column("TimeOnly", "time(6)", manyTypesTable); manyTypesTable.Columns.Add("TimeOnly", timeOnlyColumn); + timeOnlyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(timeOnlyColumn); var timeOnlyArrayColumn = new Column("TimeOnlyArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("TimeOnlyArray", timeOnlyArrayColumn); + timeOnlyArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(timeOnlyArrayColumn); var timeOnlyToStringConverterPropertyColumn = new Column("TimeOnlyToStringConverterProperty", "varchar(48)", manyTypesTable); manyTypesTable.Columns.Add("TimeOnlyToStringConverterProperty", timeOnlyToStringConverterPropertyColumn); + timeOnlyToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(timeOnlyToStringConverterPropertyColumn); var timeOnlyToTicksConverterPropertyColumn = new Column("TimeOnlyToTicksConverterProperty", "bigint", manyTypesTable); manyTypesTable.Columns.Add("TimeOnlyToTicksConverterProperty", timeOnlyToTicksConverterPropertyColumn); + timeOnlyToTicksConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(timeOnlyToTicksConverterPropertyColumn); var timeSpanColumn = new Column("TimeSpan", "time(6)", manyTypesTable); manyTypesTable.Columns.Add("TimeSpan", timeSpanColumn); + timeSpanColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(timeSpanColumn); var timeSpanArrayColumn = new Column("TimeSpanArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("TimeSpanArray", timeSpanArrayColumn); + timeSpanArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(timeSpanArrayColumn); var timeSpanToStringConverterPropertyColumn = new Column("TimeSpanToStringConverterProperty", "varchar(48)", manyTypesTable); manyTypesTable.Columns.Add("TimeSpanToStringConverterProperty", timeSpanToStringConverterPropertyColumn); + timeSpanToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(timeSpanToStringConverterPropertyColumn); var timeSpanToTicksConverterPropertyColumn = new Column("TimeSpanToTicksConverterProperty", "bigint", manyTypesTable); manyTypesTable.Columns.Add("TimeSpanToTicksConverterProperty", timeSpanToTicksConverterPropertyColumn); + timeSpanToTicksConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(timeSpanToTicksConverterPropertyColumn); var uInt16Column = new Column("UInt16", "smallint unsigned", manyTypesTable); manyTypesTable.Columns.Add("UInt16", uInt16Column); + uInt16Column.Accessors = ColumnAccessorsFactory.CreateGeneric(uInt16Column); var uInt16ArrayColumn = new Column("UInt16Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("UInt16Array", uInt16ArrayColumn); + uInt16ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(uInt16ArrayColumn); var uInt32Column = new Column("UInt32", "int unsigned", manyTypesTable); manyTypesTable.Columns.Add("UInt32", uInt32Column); + uInt32Column.Accessors = ColumnAccessorsFactory.CreateGeneric(uInt32Column); var uInt32ArrayColumn = new Column("UInt32Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("UInt32Array", uInt32ArrayColumn); + uInt32ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(uInt32ArrayColumn); var uInt64Column = new Column("UInt64", "bigint unsigned", manyTypesTable); manyTypesTable.Columns.Add("UInt64", uInt64Column); + uInt64Column.Accessors = ColumnAccessorsFactory.CreateGeneric(uInt64Column); var uInt64ArrayColumn = new Column("UInt64Array", "longtext", manyTypesTable); manyTypesTable.Columns.Add("UInt64Array", uInt64ArrayColumn); + uInt64ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(uInt64ArrayColumn); var uInt8Column = new Column("UInt8", "tinyint unsigned", manyTypesTable); manyTypesTable.Columns.Add("UInt8", uInt8Column); + uInt8Column.Accessors = ColumnAccessorsFactory.CreateGeneric(uInt8Column); var uInt8ArrayColumn = new Column("UInt8Array", "longblob", manyTypesTable); manyTypesTable.Columns.Add("UInt8Array", uInt8ArrayColumn); + uInt8ArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(uInt8ArrayColumn); var uriColumn = new Column("Uri", "longtext", manyTypesTable); manyTypesTable.Columns.Add("Uri", uriColumn); + uriColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(uriColumn); var uriArrayColumn = new Column("UriArray", "longtext", manyTypesTable); manyTypesTable.Columns.Add("UriArray", uriArrayColumn); + uriArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(uriArrayColumn); var uriToStringConverterPropertyColumn = new Column("UriToStringConverterProperty", "longtext", manyTypesTable); manyTypesTable.Columns.Add("UriToStringConverterProperty", uriToStringConverterPropertyColumn); - var pK_ManyTypes = new UniqueConstraint("PK_ManyTypes", manyTypesTable, new[] { idColumn1 }); - manyTypesTable.PrimaryKey = pK_ManyTypes; - var pK_ManyTypesUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+ManyTypes", - new[] { "Id" }); - pK_ManyTypes.MappedKeys.Add(pK_ManyTypesUc); - RelationalModel.GetOrCreateUniqueConstraints(pK_ManyTypesUc).Add(pK_ManyTypes); - manyTypesTable.UniqueConstraints.Add("PK_ManyTypes", pK_ManyTypes); + uriToStringConverterPropertyColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(uriToStringConverterPropertyColumn); relationalModel.Tables.Add(("ManyTypes", null), manyTypesTable); var manyTypesTableMapping = new TableMapping(manyTypes, manyTypesTable, null); manyTypesTable.AddTypeMapping(manyTypesTableMapping, false); @@ -1945,6 +2189,15 @@ private IRelationalModel CreateRelationalModel() RelationalModel.CreateColumnMapping(uriColumn, manyTypes.FindProperty("Uri")!, manyTypesTableMapping); RelationalModel.CreateColumnMapping(uriArrayColumn, manyTypes.FindProperty("UriArray")!, manyTypesTableMapping); RelationalModel.CreateColumnMapping(uriToStringConverterPropertyColumn, manyTypes.FindProperty("UriToStringConverterProperty")!, manyTypesTableMapping); + var pK_ManyTypes = new UniqueConstraint("PK_ManyTypes", manyTypesTable, new[] { idColumn1 }); + manyTypesTable.PrimaryKey = pK_ManyTypes; + pK_ManyTypes.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(pK_ManyTypes)); + var pK_ManyTypesKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+ManyTypes", + new[] { "Id" }); + pK_ManyTypes.MappedKeys.Add(pK_ManyTypesKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_ManyTypesKey).Add(pK_ManyTypes); + manyTypesTable.UniqueConstraints.Add("PK_ManyTypes", pK_ManyTypes); var principalBase = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase")!; @@ -2048,144 +2301,142 @@ private IRelationalModel CreateRelationalModel() var principalBaseTable = new Table("PrincipalBase", "mySchema", relationalModel); var idColumn2 = new Column("Id", "bigint", principalBaseTable); principalBaseTable.Columns.Add("Id", idColumn2); + idColumn2.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn2); var alternateIdColumn = new Column("AlternateId", "char(36)", principalBaseTable); principalBaseTable.Columns.Add("AlternateId", alternateIdColumn); + alternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(alternateIdColumn); var enum1Column = new Column("Enum1", "int", principalBaseTable); principalBaseTable.Columns.Add("Enum1", enum1Column); + enum1Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enum1Column); var enum2Column = new Column("Enum2", "int", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Enum2", enum2Column); + enum2Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enum2Column); var flagsEnum1Column = new Column("FlagsEnum1", "int", principalBaseTable); principalBaseTable.Columns.Add("FlagsEnum1", flagsEnum1Column); + flagsEnum1Column.Accessors = ColumnAccessorsFactory.CreateGeneric(flagsEnum1Column); var flagsEnum2Column = new Column("FlagsEnum2", "int", principalBaseTable); principalBaseTable.Columns.Add("FlagsEnum2", flagsEnum2Column); + flagsEnum2Column.Accessors = ColumnAccessorsFactory.CreateGeneric(flagsEnum2Column); var owned_NumberColumn = new Column("Owned_Number", "int", principalBaseTable); principalBaseTable.Columns.Add("Owned_Number", owned_NumberColumn); + owned_NumberColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(owned_NumberColumn); var owned_RefTypeArrayColumn = new Column("Owned_RefTypeArray", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Owned_RefTypeArray", owned_RefTypeArrayColumn); + owned_RefTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(owned_RefTypeArrayColumn); var owned_RefTypeEnumerableColumn = new Column("Owned_RefTypeEnumerable", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Owned_RefTypeEnumerable", owned_RefTypeEnumerableColumn); + owned_RefTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(owned_RefTypeEnumerableColumn); var owned_RefTypeIListColumn = new Column("Owned_RefTypeIList", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Owned_RefTypeIList", owned_RefTypeIListColumn); + owned_RefTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(owned_RefTypeIListColumn); var owned_RefTypeListColumn = new Column("Owned_RefTypeList", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Owned_RefTypeList", owned_RefTypeListColumn); + owned_RefTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(owned_RefTypeListColumn); var owned_ValueTypeArrayColumn = new Column("Owned_ValueTypeArray", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Owned_ValueTypeArray", owned_ValueTypeArrayColumn); + owned_ValueTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(owned_ValueTypeArrayColumn); var owned_ValueTypeEnumerableColumn = new Column("Owned_ValueTypeEnumerable", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Owned_ValueTypeEnumerable", owned_ValueTypeEnumerableColumn); + owned_ValueTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(owned_ValueTypeEnumerableColumn); var owned_ValueTypeIListColumn = new Column("Owned_ValueTypeIList", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Owned_ValueTypeIList", owned_ValueTypeIListColumn); + owned_ValueTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(owned_ValueTypeIListColumn); var owned_ValueTypeListColumn = new Column("Owned_ValueTypeList", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Owned_ValueTypeList", owned_ValueTypeListColumn); + owned_ValueTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(owned_ValueTypeListColumn); var pointColumn0 = new Column("Point", "geometry", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("Point", pointColumn0); + pointColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(pointColumn0); var refTypeArrayColumn = new Column("RefTypeArray", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("RefTypeArray", refTypeArrayColumn); + refTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeArrayColumn); var refTypeEnumerableColumn = new Column("RefTypeEnumerable", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumn); + refTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeEnumerableColumn); var refTypeIListColumn = new Column("RefTypeIList", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("RefTypeIList", refTypeIListColumn); + refTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeIListColumn); var refTypeListColumn = new Column("RefTypeList", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("RefTypeList", refTypeListColumn); + refTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeListColumn); var stringWithCharSetColumn0 = new Column("StringWithCharSet", "varchar(128)", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("StringWithCharSet", stringWithCharSetColumn0); + stringWithCharSetColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(stringWithCharSetColumn0); var stringWithCollationColumn0 = new Column("StringWithCollation", "varchar(128)", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("StringWithCollation", stringWithCollationColumn0); + stringWithCollationColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(stringWithCollationColumn0); var valueTypeArrayColumn = new Column("ValueTypeArray", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("ValueTypeArray", valueTypeArrayColumn); + valueTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeArrayColumn); var valueTypeEnumerableColumn = new Column("ValueTypeEnumerable", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumn); + valueTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeEnumerableColumn); var valueTypeIListColumn = new Column("ValueTypeIList", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("ValueTypeIList", valueTypeIListColumn); + valueTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeIListColumn); var valueTypeListColumn = new Column("ValueTypeList", "longtext", principalBaseTable) { IsNullable = true }; principalBaseTable.Columns.Add("ValueTypeList", valueTypeListColumn); - var aK_PrincipalBase_Id = new UniqueConstraint("AK_PrincipalBase_Id", principalBaseTable, new[] { idColumn2 }); - var aK_PrincipalBase_IdUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", - new[] { "Id" }); - aK_PrincipalBase_Id.MappedKeys.Add(aK_PrincipalBase_IdUc); - RelationalModel.GetOrCreateUniqueConstraints(aK_PrincipalBase_IdUc).Add(aK_PrincipalBase_Id); - principalBaseTable.UniqueConstraints.Add("AK_PrincipalBase_Id", aK_PrincipalBase_Id); - var pK = new UniqueConstraint("PK", principalBaseTable, new[] { idColumn2, alternateIdColumn }); - principalBaseTable.PrimaryKey = pK; - var pKUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", - new[] { "Id", "AlternateId" }); - pK.MappedKeys.Add(pKUc); - RelationalModel.GetOrCreateUniqueConstraints(pKUc).Add(pK); - var pKUc0 = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType", - new[] { "PrincipalBaseId", "PrincipalBaseAlternateId" }); - pK.MappedKeys.Add(pKUc0); - RelationalModel.GetOrCreateUniqueConstraints(pKUc0).Add(pK); - principalBaseTable.UniqueConstraints.Add("PK", pK); - var iX_PrincipalBase_AlternateId_Id = new TableIndex( - "IX_PrincipalBase_AlternateId_Id", principalBaseTable, new[] { alternateIdColumn, idColumn2 }, false); - var iX_PrincipalBase_AlternateId_IdIx = RelationalModel.GetIndex(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", - new[] { "AlternateId", "Id" }); - iX_PrincipalBase_AlternateId_Id.MappedIndexes.Add(iX_PrincipalBase_AlternateId_IdIx); - RelationalModel.GetOrCreateTableIndexes(iX_PrincipalBase_AlternateId_IdIx).Add(iX_PrincipalBase_AlternateId_Id); - principalBaseTable.Indexes.Add("IX_PrincipalBase_AlternateId_Id", iX_PrincipalBase_AlternateId_Id); + valueTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeListColumn); relationalModel.Tables.Add(("PrincipalBase", "mySchema"), principalBaseTable); var principalBaseTableMapping = new TableMapping(principalBase, principalBaseTable, true) { @@ -2312,21 +2563,16 @@ private IRelationalModel CreateRelationalModel() var detailsTable = new Table("Details", null, relationalModel); var principalBaseIdColumn = new Column("PrincipalBaseId", "bigint", detailsTable); detailsTable.Columns.Add("PrincipalBaseId", principalBaseIdColumn); + principalBaseIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalBaseIdColumn); var principalBaseAlternateIdColumn = new Column("PrincipalBaseAlternateId", "char(36)", detailsTable); detailsTable.Columns.Add("PrincipalBaseAlternateId", principalBaseAlternateIdColumn); + principalBaseAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalBaseAlternateIdColumn); var detailsColumn = new Column("Details", "longtext", detailsTable) { IsNullable = true }; detailsTable.Columns.Add("Details", detailsColumn); - var pK_Details = new UniqueConstraint("PK_Details", detailsTable, new[] { principalBaseIdColumn, principalBaseAlternateIdColumn }); - detailsTable.PrimaryKey = pK_Details; - var pK_DetailsUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType", - new[] { "PrincipalBaseId", "PrincipalBaseAlternateId" }); - pK_Details.MappedKeys.Add(pK_DetailsUc); - RelationalModel.GetOrCreateUniqueConstraints(pK_DetailsUc).Add(pK_Details); - detailsTable.UniqueConstraints.Add("PK_Details", pK_Details); + detailsColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(detailsColumn); relationalModel.Tables.Add(("Details", null), detailsTable); var detailsTableMapping = new TableMapping(ownedType, detailsTable, null) { @@ -2337,6 +2583,15 @@ private IRelationalModel CreateRelationalModel() RelationalModel.CreateColumnMapping(principalBaseAlternateIdColumn, ownedType.FindProperty("PrincipalBaseAlternateId")!, detailsTableMapping); RelationalModel.CreateColumnMapping(principalBaseIdColumn, ownedType.FindProperty("PrincipalBaseId")!, detailsTableMapping); RelationalModel.CreateColumnMapping(detailsColumn, ownedType.FindProperty("Details")!, detailsTableMapping); + var pK_Details = new UniqueConstraint("PK_Details", detailsTable, new[] { principalBaseIdColumn, principalBaseAlternateIdColumn }); + detailsTable.PrimaryKey = pK_Details; + pK_Details.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK_Details)); + var pK_DetailsKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType", + new[] { "PrincipalBaseId", "PrincipalBaseAlternateId" }); + pK_Details.MappedKeys.Add(pK_DetailsKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_DetailsKey).Add(pK_Details); + detailsTable.UniqueConstraints.Add("PK_Details", pK_Details); var principalDerived = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>")!; @@ -2399,40 +2654,64 @@ private IRelationalModel CreateRelationalModel() RelationalModel.CreateColumnMapping(valueTypeEnumerableColumn, principalDerived.FindProperty("ValueTypeEnumerable")!, principalBaseTableMapping1); RelationalModel.CreateColumnMapping(valueTypeIListColumn, principalDerived.FindProperty("ValueTypeIList")!, principalBaseTableMapping1); RelationalModel.CreateColumnMapping(valueTypeListColumn, principalDerived.FindProperty("ValueTypeList")!, principalBaseTableMapping1); + var aK_PrincipalBase_Id = new UniqueConstraint("AK_PrincipalBase_Id", principalBaseTable, new[] { idColumn2 }); + aK_PrincipalBase_Id.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(aK_PrincipalBase_Id)); + var aK_PrincipalBase_IdKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", + new[] { "Id" }); + aK_PrincipalBase_Id.MappedKeys.Add(aK_PrincipalBase_IdKey); + RelationalModel.GetOrCreateUniqueConstraints(aK_PrincipalBase_IdKey).Add(aK_PrincipalBase_Id); + principalBaseTable.UniqueConstraints.Add("AK_PrincipalBase_Id", aK_PrincipalBase_Id); + var pK = new UniqueConstraint("PK", principalBaseTable, new[] { idColumn2, alternateIdColumn }); + principalBaseTable.PrimaryKey = pK; + pK.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK)); + var pKKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", + new[] { "Id", "AlternateId" }); + pK.MappedKeys.Add(pKKey); + RelationalModel.GetOrCreateUniqueConstraints(pKKey).Add(pK); + pK.MappedKeys.Add(pK_DetailsKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_DetailsKey).Add(pK); + principalBaseTable.UniqueConstraints.Add("PK", pK); + var iX_PrincipalBase_AlternateId_Id = new TableIndex( + "IX_PrincipalBase_AlternateId_Id", principalBaseTable, new[] { alternateIdColumn, idColumn2 }, false); + iX_PrincipalBase_AlternateId_Id.SetRowIndexValueFactory(new CompositeRowIndexValueFactory(iX_PrincipalBase_AlternateId_Id)); + var iX_PrincipalBase_AlternateId_IdIx = RelationalModel.GetIndex(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", + new[] { "AlternateId", "Id" }); + iX_PrincipalBase_AlternateId_Id.MappedIndexes.Add(iX_PrincipalBase_AlternateId_IdIx); + RelationalModel.GetOrCreateTableIndexes(iX_PrincipalBase_AlternateId_IdIx).Add(iX_PrincipalBase_AlternateId_Id); + principalBaseTable.Indexes.Add("IX_PrincipalBase_AlternateId_Id", iX_PrincipalBase_AlternateId_Id); var principalDerivedTable = new Table("PrincipalDerived", null, relationalModel); var derivedIdColumn = new Column("DerivedId", "bigint", principalDerivedTable); principalDerivedTable.Columns.Add("DerivedId", derivedIdColumn); + derivedIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(derivedIdColumn); var alternateIdColumn0 = new Column("AlternateId", "char(36)", principalDerivedTable); principalDerivedTable.Columns.Add("AlternateId", alternateIdColumn0); + alternateIdColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(alternateIdColumn0); + relationalModel.Tables.Add(("PrincipalDerived", null), principalDerivedTable); + var principalDerivedTableMapping = new TableMapping(principalDerived, principalDerivedTable, null); + principalDerivedTable.AddTypeMapping(principalDerivedTableMapping, false); + tableMappings5.Add(principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(alternateIdColumn0, principalDerived.FindProperty("AlternateId")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(derivedIdColumn, principalDerived.FindProperty("Id")!, principalDerivedTableMapping); var aK_PrincipalDerived_DerivedId = new UniqueConstraint("AK_PrincipalDerived_DerivedId", principalDerivedTable, new[] { derivedIdColumn }); - var aK_PrincipalDerived_DerivedIdUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", - new[] { "Id" }); - aK_PrincipalDerived_DerivedId.MappedKeys.Add(aK_PrincipalDerived_DerivedIdUc); - RelationalModel.GetOrCreateUniqueConstraints(aK_PrincipalDerived_DerivedIdUc).Add(aK_PrincipalDerived_DerivedId); + aK_PrincipalDerived_DerivedId.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(aK_PrincipalDerived_DerivedId)); + aK_PrincipalDerived_DerivedId.MappedKeys.Add(aK_PrincipalBase_IdKey); + RelationalModel.GetOrCreateUniqueConstraints(aK_PrincipalBase_IdKey).Add(aK_PrincipalDerived_DerivedId); principalDerivedTable.UniqueConstraints.Add("AK_PrincipalDerived_DerivedId", aK_PrincipalDerived_DerivedId); var pK0 = new UniqueConstraint("PK", principalDerivedTable, new[] { derivedIdColumn, alternateIdColumn0 }); principalDerivedTable.PrimaryKey = pK0; - var pK0Uc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", - new[] { "Id", "AlternateId" }); - pK0.MappedKeys.Add(pK0Uc); - RelationalModel.GetOrCreateUniqueConstraints(pK0Uc).Add(pK0); + pK0.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK0)); + pK0.MappedKeys.Add(pKKey); + RelationalModel.GetOrCreateUniqueConstraints(pKKey).Add(pK0); principalDerivedTable.UniqueConstraints.Add("PK", pK0); var iX_PrincipalDerived_AlternateId_DerivedId = new TableIndex( "IX_PrincipalDerived_AlternateId_DerivedId", principalDerivedTable, new[] { alternateIdColumn0, derivedIdColumn }, false); - var iX_PrincipalDerived_AlternateId_DerivedIdIx = RelationalModel.GetIndex(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", - new[] { "AlternateId", "Id" }); - iX_PrincipalDerived_AlternateId_DerivedId.MappedIndexes.Add(iX_PrincipalDerived_AlternateId_DerivedIdIx); - RelationalModel.GetOrCreateTableIndexes(iX_PrincipalDerived_AlternateId_DerivedIdIx).Add(iX_PrincipalDerived_AlternateId_DerivedId); + iX_PrincipalDerived_AlternateId_DerivedId.SetRowIndexValueFactory(new CompositeRowIndexValueFactory(iX_PrincipalDerived_AlternateId_DerivedId)); + iX_PrincipalDerived_AlternateId_DerivedId.MappedIndexes.Add(iX_PrincipalBase_AlternateId_IdIx); + RelationalModel.GetOrCreateTableIndexes(iX_PrincipalBase_AlternateId_IdIx).Add(iX_PrincipalDerived_AlternateId_DerivedId); principalDerivedTable.Indexes.Add("IX_PrincipalDerived_AlternateId_DerivedId", iX_PrincipalDerived_AlternateId_DerivedId); - relationalModel.Tables.Add(("PrincipalDerived", null), principalDerivedTable); - var principalDerivedTableMapping = new TableMapping(principalDerived, principalDerivedTable, null); - principalDerivedTable.AddTypeMapping(principalDerivedTableMapping, false); - tableMappings5.Add(principalDerivedTableMapping); - RelationalModel.CreateColumnMapping(alternateIdColumn0, principalDerived.FindProperty("AlternateId")!, principalDerivedTableMapping); - RelationalModel.CreateColumnMapping(derivedIdColumn, principalDerived.FindProperty("Id")!, principalDerivedTableMapping); var ownedType0 = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>.ManyOwned#OwnedType")!; @@ -2515,65 +2794,70 @@ private IRelationalModel CreateRelationalModel() var manyOwnedTable = new Table("ManyOwned", null, relationalModel); var principalDerivedDependentBasebyteIdColumn = new Column("PrincipalDerived>Id", "bigint", manyOwnedTable); manyOwnedTable.Columns.Add("PrincipalDerived>Id", principalDerivedDependentBasebyteIdColumn); + principalDerivedDependentBasebyteIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalDerivedDependentBasebyteIdColumn); var principalDerivedDependentBasebyteAlternateIdColumn = new Column("PrincipalDerived>AlternateId", "char(36)", manyOwnedTable); manyOwnedTable.Columns.Add("PrincipalDerived>AlternateId", principalDerivedDependentBasebyteAlternateIdColumn); + principalDerivedDependentBasebyteAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalDerivedDependentBasebyteAlternateIdColumn); var idColumn3 = new Column("Id", "int", manyOwnedTable); manyOwnedTable.Columns.Add("Id", idColumn3); + idColumn3.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn3); var detailsColumn0 = new Column("Details", "longtext", manyOwnedTable) { IsNullable = true }; manyOwnedTable.Columns.Add("Details", detailsColumn0); + detailsColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(detailsColumn0); var numberColumn = new Column("Number", "int", manyOwnedTable); manyOwnedTable.Columns.Add("Number", numberColumn); + numberColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(numberColumn); var refTypeArrayColumn0 = new Column("RefTypeArray", "longtext", manyOwnedTable) { IsNullable = true }; manyOwnedTable.Columns.Add("RefTypeArray", refTypeArrayColumn0); + refTypeArrayColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeArrayColumn0); var refTypeEnumerableColumn0 = new Column("RefTypeEnumerable", "longtext", manyOwnedTable) { IsNullable = true }; manyOwnedTable.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumn0); + refTypeEnumerableColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeEnumerableColumn0); var refTypeIListColumn0 = new Column("RefTypeIList", "longtext", manyOwnedTable) { IsNullable = true }; manyOwnedTable.Columns.Add("RefTypeIList", refTypeIListColumn0); + refTypeIListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeIListColumn0); var refTypeListColumn0 = new Column("RefTypeList", "longtext", manyOwnedTable) { IsNullable = true }; manyOwnedTable.Columns.Add("RefTypeList", refTypeListColumn0); + refTypeListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeListColumn0); var valueTypeArrayColumn0 = new Column("ValueTypeArray", "longtext", manyOwnedTable) { IsNullable = true }; manyOwnedTable.Columns.Add("ValueTypeArray", valueTypeArrayColumn0); + valueTypeArrayColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeArrayColumn0); var valueTypeEnumerableColumn0 = new Column("ValueTypeEnumerable", "longtext", manyOwnedTable) { IsNullable = true }; manyOwnedTable.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumn0); + valueTypeEnumerableColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeEnumerableColumn0); var valueTypeIListColumn0 = new Column("ValueTypeIList", "longtext", manyOwnedTable) { IsNullable = true }; manyOwnedTable.Columns.Add("ValueTypeIList", valueTypeIListColumn0); + valueTypeIListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeIListColumn0); var valueTypeListColumn0 = new Column("ValueTypeList", "longtext", manyOwnedTable) { IsNullable = true }; manyOwnedTable.Columns.Add("ValueTypeList", valueTypeListColumn0); - var pK_ManyOwned = new UniqueConstraint("PK_ManyOwned", manyOwnedTable, new[] { principalDerivedDependentBasebyteIdColumn, principalDerivedDependentBasebyteAlternateIdColumn, idColumn3 }); - manyOwnedTable.PrimaryKey = pK_ManyOwned; - var pK_ManyOwnedUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>.ManyOwned#OwnedType", - new[] { "PrincipalDerivedId", "PrincipalDerivedAlternateId", "Id" }); - pK_ManyOwned.MappedKeys.Add(pK_ManyOwnedUc); - RelationalModel.GetOrCreateUniqueConstraints(pK_ManyOwnedUc).Add(pK_ManyOwned); - manyOwnedTable.UniqueConstraints.Add("PK_ManyOwned", pK_ManyOwned); + valueTypeListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeListColumn0); relationalModel.Tables.Add(("ManyOwned", null), manyOwnedTable); var manyOwnedTableMapping = new TableMapping(ownedType0, manyOwnedTable, null); manyOwnedTable.AddTypeMapping(manyOwnedTableMapping, false); @@ -2591,6 +2875,15 @@ private IRelationalModel CreateRelationalModel() RelationalModel.CreateColumnMapping(valueTypeEnumerableColumn0, ownedType0.FindProperty("ValueTypeEnumerable")!, manyOwnedTableMapping); RelationalModel.CreateColumnMapping(valueTypeIListColumn0, ownedType0.FindProperty("ValueTypeIList")!, manyOwnedTableMapping); RelationalModel.CreateColumnMapping(valueTypeListColumn0, ownedType0.FindProperty("ValueTypeList")!, manyOwnedTableMapping); + var pK_ManyOwned = new UniqueConstraint("PK_ManyOwned", manyOwnedTable, new[] { principalDerivedDependentBasebyteIdColumn, principalDerivedDependentBasebyteAlternateIdColumn, idColumn3 }); + manyOwnedTable.PrimaryKey = pK_ManyOwned; + pK_ManyOwned.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK_ManyOwned)); + var pK_ManyOwnedKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>.ManyOwned#OwnedType", + new[] { "PrincipalDerivedId", "PrincipalDerivedAlternateId", "Id" }); + pK_ManyOwned.MappedKeys.Add(pK_ManyOwnedKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_ManyOwnedKey).Add(pK_ManyOwned); + manyOwnedTable.UniqueConstraints.Add("PK_ManyOwned", pK_ManyOwned); var principalBasePrincipalDerivedDependentBasebyte = FindEntityType("PrincipalBasePrincipalDerived>")!; @@ -2625,46 +2918,54 @@ private IRelationalModel CreateRelationalModel() var principalBasePrincipalDerivedDependentBasebyteTable = new Table("PrincipalBasePrincipalDerived>", null, relationalModel); var derivedsIdColumn = new Column("DerivedsId", "bigint", principalBasePrincipalDerivedDependentBasebyteTable); principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("DerivedsId", derivedsIdColumn); + derivedsIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(derivedsIdColumn); var derivedsAlternateIdColumn = new Column("DerivedsAlternateId", "char(36)", principalBasePrincipalDerivedDependentBasebyteTable); principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("DerivedsAlternateId", derivedsAlternateIdColumn); + derivedsAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(derivedsAlternateIdColumn); var principalsIdColumn = new Column("PrincipalsId", "bigint", principalBasePrincipalDerivedDependentBasebyteTable); principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("PrincipalsId", principalsIdColumn); + principalsIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalsIdColumn); var principalsAlternateIdColumn = new Column("PrincipalsAlternateId", "char(36)", principalBasePrincipalDerivedDependentBasebyteTable); principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("PrincipalsAlternateId", principalsAlternateIdColumn); + principalsAlternateIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalsAlternateIdColumn); var rowidColumn = new Column("rowid", "timestamp(6)", principalBasePrincipalDerivedDependentBasebyteTable) { IsNullable = true }; principalBasePrincipalDerivedDependentBasebyteTable.Columns.Add("rowid", rowidColumn); + rowidColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(rowidColumn); + relationalModel.Tables.Add(("PrincipalBasePrincipalDerived>", null), principalBasePrincipalDerivedDependentBasebyteTable); + var principalBasePrincipalDerivedDependentBasebyteTableMapping = new TableMapping(principalBasePrincipalDerivedDependentBasebyte, principalBasePrincipalDerivedDependentBasebyteTable, null); + principalBasePrincipalDerivedDependentBasebyteTable.AddTypeMapping(principalBasePrincipalDerivedDependentBasebyteTableMapping, false); + tableMappings7.Add(principalBasePrincipalDerivedDependentBasebyteTableMapping); + RelationalModel.CreateColumnMapping(derivedsAlternateIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("DerivedsAlternateId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); + RelationalModel.CreateColumnMapping(derivedsIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("DerivedsId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); + RelationalModel.CreateColumnMapping(principalsAlternateIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("PrincipalsAlternateId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); + RelationalModel.CreateColumnMapping(principalsIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("PrincipalsId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); + RelationalModel.CreateColumnMapping(rowidColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("rowid")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); var pK_PrincipalBasePrincipalDerivedDependentBasebyte = new UniqueConstraint("PK_PrincipalBasePrincipalDerived>", principalBasePrincipalDerivedDependentBasebyteTable, new[] { derivedsIdColumn, derivedsAlternateIdColumn, principalsIdColumn, principalsAlternateIdColumn }); principalBasePrincipalDerivedDependentBasebyteTable.PrimaryKey = pK_PrincipalBasePrincipalDerivedDependentBasebyte; - var pK_PrincipalBasePrincipalDerivedDependentBasebyteUc = RelationalModel.GetKey(this, + pK_PrincipalBasePrincipalDerivedDependentBasebyte.SetRowKeyValueFactory(new CompositeRowKeyValueFactory(pK_PrincipalBasePrincipalDerivedDependentBasebyte)); + var pK_PrincipalBasePrincipalDerivedDependentBasebyteKey = RelationalModel.GetKey(this, "PrincipalBasePrincipalDerived>", new[] { "DerivedsId", "DerivedsAlternateId", "PrincipalsId", "PrincipalsAlternateId" }); - pK_PrincipalBasePrincipalDerivedDependentBasebyte.MappedKeys.Add(pK_PrincipalBasePrincipalDerivedDependentBasebyteUc); - RelationalModel.GetOrCreateUniqueConstraints(pK_PrincipalBasePrincipalDerivedDependentBasebyteUc).Add(pK_PrincipalBasePrincipalDerivedDependentBasebyte); + pK_PrincipalBasePrincipalDerivedDependentBasebyte.MappedKeys.Add(pK_PrincipalBasePrincipalDerivedDependentBasebyteKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_PrincipalBasePrincipalDerivedDependentBasebyteKey).Add(pK_PrincipalBasePrincipalDerivedDependentBasebyte); principalBasePrincipalDerivedDependentBasebyteTable.UniqueConstraints.Add("PK_PrincipalBasePrincipalDerived>", pK_PrincipalBasePrincipalDerivedDependentBasebyte); var iX_PrincipalBasePrincipalDerivedDependentBasebyte_Principa = new TableIndex( "IX_PrincipalBasePrincipalDerived>_Principa~", principalBasePrincipalDerivedDependentBasebyteTable, new[] { principalsIdColumn, principalsAlternateIdColumn }, false); + iX_PrincipalBasePrincipalDerivedDependentBasebyte_Principa.SetRowIndexValueFactory(new CompositeRowIndexValueFactory(iX_PrincipalBasePrincipalDerivedDependentBasebyte_Principa)); var iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipaIx = RelationalModel.GetIndex(this, "PrincipalBasePrincipalDerived>", new[] { "PrincipalsId", "PrincipalsAlternateId" }); iX_PrincipalBasePrincipalDerivedDependentBasebyte_Principa.MappedIndexes.Add(iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipaIx); RelationalModel.GetOrCreateTableIndexes(iX_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipaIx).Add(iX_PrincipalBasePrincipalDerivedDependentBasebyte_Principa); principalBasePrincipalDerivedDependentBasebyteTable.Indexes.Add("IX_PrincipalBasePrincipalDerived>_Principa~", iX_PrincipalBasePrincipalDerivedDependentBasebyte_Principa); - relationalModel.Tables.Add(("PrincipalBasePrincipalDerived>", null), principalBasePrincipalDerivedDependentBasebyteTable); - var principalBasePrincipalDerivedDependentBasebyteTableMapping = new TableMapping(principalBasePrincipalDerivedDependentBasebyte, principalBasePrincipalDerivedDependentBasebyteTable, null); - principalBasePrincipalDerivedDependentBasebyteTable.AddTypeMapping(principalBasePrincipalDerivedDependentBasebyteTableMapping, false); - tableMappings7.Add(principalBasePrincipalDerivedDependentBasebyteTableMapping); - RelationalModel.CreateColumnMapping(derivedsAlternateIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("DerivedsAlternateId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); - RelationalModel.CreateColumnMapping(derivedsIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("DerivedsId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); - RelationalModel.CreateColumnMapping(principalsAlternateIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("PrincipalsAlternateId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); - RelationalModel.CreateColumnMapping(principalsIdColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("PrincipalsId")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); - RelationalModel.CreateColumnMapping(rowidColumn, principalBasePrincipalDerivedDependentBasebyte.FindProperty("rowid")!, principalBasePrincipalDerivedDependentBasebyteTableMapping); var fK_DependentBasebyte_PrincipalBase_PrincipalId = new ForeignKeyConstraint( "FK_DependentBase_PrincipalBase_PrincipalId", dependentBasebyteTable, principalBaseTable, new[] { principalIdColumn }, principalBaseTable.FindUniqueConstraint("AK_PrincipalBase_Id")!, ReferentialAction.Cascade); + fK_DependentBasebyte_PrincipalBase_PrincipalId.SetRowForeignKeyValueFactory(RowForeignKeyValueFactoryFactory.CreateSimpleNonNullableFactory(fK_DependentBasebyte_PrincipalBase_PrincipalId)); var fK_DependentBasebyte_PrincipalBase_PrincipalIdFk = RelationalModel.GetForeignKey(this, "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", new[] { "PrincipalId" }, @@ -2678,6 +2979,7 @@ private IRelationalModel CreateRelationalModel() "FK_DependentBase_PrincipalDerived_PrincipalId_PrincipalA~", dependentBasebyteTable, principalDerivedTable, new[] { principalIdColumn, principalAlternateIdColumn }, principalDerivedTable.FindUniqueConstraint("PK")!, ReferentialAction.NoAction); + fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalA.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalA)); var fK_DependentBasebyte_PrincipalDerived_PrincipalId_PrincipalAFk = RelationalModel.GetForeignKey(this, "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", new[] { "PrincipalId", "PrincipalAlternateId" }, @@ -2691,6 +2993,7 @@ private IRelationalModel CreateRelationalModel() "FK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternate~", detailsTable, principalBaseTable, new[] { principalBaseIdColumn, principalBaseAlternateIdColumn }, principalBaseTable.FindUniqueConstraint("PK")!, ReferentialAction.Cascade); + fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternate.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternate)); var fK_Details_PrincipalBase_PrincipalBaseId_PrincipalBaseAlternateFk = RelationalModel.GetForeignKey(this, "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType", new[] { "PrincipalBaseId", "PrincipalBaseAlternateId" }, @@ -2704,6 +3007,7 @@ private IRelationalModel CreateRelationalModel() "FK_ManyOwned_PrincipalDerived_PrincipalDerived>.ManyOwned#OwnedType", new[] { "PrincipalDerivedId", "PrincipalDerivedAlternateId" }, @@ -2717,6 +3021,7 @@ private IRelationalModel CreateRelationalModel() "FK_PrincipalBasePrincipalDerived>_Principa~", principalBasePrincipalDerivedDependentBasebyteTable, principalDerivedTable, new[] { derivedsIdColumn, derivedsAlternateIdColumn }, principalDerivedTable.FindUniqueConstraint("PK")!, ReferentialAction.Cascade); + fK_PrincipalBasePrincipalDerivedDependentBasebyte_Principa.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_PrincipalBasePrincipalDerivedDependentBasebyte_Principa)); var fK_PrincipalBasePrincipalDerivedDependentBasebyte_PrincipaFk = RelationalModel.GetForeignKey(this, "PrincipalBasePrincipalDerived>", new[] { "DerivedsId", "DerivedsAlternateId" }, @@ -2730,6 +3035,7 @@ private IRelationalModel CreateRelationalModel() "FK_PrincipalBasePrincipalDerived>_Princip~1", principalBasePrincipalDerivedDependentBasebyteTable, principalBaseTable, new[] { principalsIdColumn, principalsAlternateIdColumn }, principalBaseTable.FindUniqueConstraint("PK")!, ReferentialAction.Cascade); + fK_PrincipalBasePrincipalDerivedDependentBasebyte_Princip1.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_PrincipalBasePrincipalDerivedDependentBasebyte_Princip1)); var fK_PrincipalBasePrincipalDerivedDependentBasebyte_Princip1Fk = RelationalModel.GetForeignKey(this, "PrincipalBasePrincipalDerived>", new[] { "PrincipalsId", "PrincipalsAlternateId" }, @@ -2743,6 +3049,7 @@ private IRelationalModel CreateRelationalModel() "FK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId", principalDerivedTable, principalBaseTable, new[] { derivedIdColumn, alternateIdColumn0 }, principalBaseTable.FindUniqueConstraint("PK")!, ReferentialAction.Cascade); + fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId.SetRowForeignKeyValueFactory(new CompositeRowForeignKeyValueFactory(fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateId)); var fK_PrincipalDerived_PrincipalBase_DerivedId_AlternateIdFk = RelationalModel.GetForeignKey(this, "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>", new[] { "Id", "AlternateId" }, diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentBaseEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentBaseEntityType.cs index 9f6286a9c..1aced9e17 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentBaseEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentBaseEntityType.cs @@ -1,10 +1,15 @@ // using System; +using System.Collections.Generic; using System.Reflection; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.Storage.Json; using Microsoft.EntityFrameworkCore.Storage.ValueConversion; using Microsoft.EntityFrameworkCore.ValueGeneration; @@ -15,7 +20,8 @@ namespace TestNamespace { - internal partial class DependentBaseEntityType + [EntityFrameworkInternal] + public partial class DependentBaseEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -37,19 +43,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(long), afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: 0L); + principalId.SetAccessors( + long (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(0) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(0) && entry.ReadShadowValue(0) == 0L ? entry.ReadTemporaryValue(0) : entry.ReadShadowValue(0))), + long (InternalEntityEntry entry) => entry.ReadShadowValue(0), + long (InternalEntityEntry entry) => entry.ReadOriginalValue(principalId, 0), + long (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalId, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + principalId.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: 0, + relationshipIndex: 0, + storeGenerationIndex: 0); principalId.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), keyComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v)); + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + principalId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalId)); principalId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var principalAlternateId = runtimeEntityType.AddProperty( @@ -57,19 +76,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(Guid), afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + principalAlternateId.SetAccessors( + Guid (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(1) ? entry.ReadStoreGeneratedValue(1) : (entry.FlaggedAsTemporary(1) && entry.ReadShadowValue(1) == new Guid("00000000-0000-0000-0000-000000000000") ? entry.ReadTemporaryValue(1) : entry.ReadShadowValue(1))), + Guid (InternalEntityEntry entry) => entry.ReadShadowValue(1), + Guid (InternalEntityEntry entry) => entry.ReadOriginalValue(principalAlternateId, 1), + Guid (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalAlternateId, 1), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + principalAlternateId.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: 1, + relationshipIndex: 1, + storeGenerationIndex: 1); principalAlternateId.TypeMapping = MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v)); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)); + principalAlternateId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalAlternateId)); principalAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumDiscriminator = runtimeEntityType.AddProperty( @@ -77,27 +109,39 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum1), afterSaveBehavior: PropertySaveBehavior.Throw, valueGeneratorFactory: new DiscriminatorValueGeneratorFactory().Create); + enumDiscriminator.SetAccessors( + CompiledModelTestBase.Enum1 (InternalEntityEntry entry) => entry.ReadShadowValue(2), + CompiledModelTestBase.Enum1 (InternalEntityEntry entry) => entry.ReadShadowValue(2), + CompiledModelTestBase.Enum1 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumDiscriminator, 2), + CompiledModelTestBase.Enum1 (InternalEntityEntry entry) => entry.GetCurrentValue(enumDiscriminator), + object (ValueBuffer valueBuffer) => valueBuffer[2]); + enumDiscriminator.SetPropertyIndexes( + index: 2, + originalValueIndex: 2, + shadowIndex: 2, + relationshipIndex: -1, + storeGenerationIndex: -1); enumDiscriminator.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum1 v1, CompiledModelTestBase.Enum1 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum1 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum1 v) => v), + bool (CompiledModelTestBase.Enum1 v1, CompiledModelTestBase.Enum1 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum1 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum1 (CompiledModelTestBase.Enum1 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum1 v1, CompiledModelTestBase.Enum1 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum1 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum1 v) => v), + bool (CompiledModelTestBase.Enum1 v1, CompiledModelTestBase.Enum1 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum1 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum1 (CompiledModelTestBase.Enum1 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum1 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum1)value), + int (CompiledModelTestBase.Enum1 value) => ((int)(value)), + CompiledModelTestBase.Enum1 (int value) => ((CompiledModelTestBase.Enum1)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum1 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum1)value))); + int (CompiledModelTestBase.Enum1 value) => ((int)(value)), + CompiledModelTestBase.Enum1 (int value) => ((CompiledModelTestBase.Enum1)(value))))); enumDiscriminator.SetSentinelFromProviderValue(0); enumDiscriminator.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -107,19 +151,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.DependentBase).GetProperty("Id", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.DependentBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + id.SetGetter( + byte? (CompiledModelTestBase.DependentBase entity) => DependentBaseUnsafeAccessors.Id(entity), + bool (CompiledModelTestBase.DependentBase entity) => !(DependentBaseUnsafeAccessors.Id(entity).HasValue), + byte? (CompiledModelTestBase.DependentBase instance) => DependentBaseUnsafeAccessors.Id(instance), + bool (CompiledModelTestBase.DependentBase instance) => !(DependentBaseUnsafeAccessors.Id(instance).HasValue)); + id.SetSetter( + (CompiledModelTestBase.DependentBase entity, byte? value) => DependentBaseUnsafeAccessors.Id(entity) = value); + id.SetMaterializationSetter( + (CompiledModelTestBase.DependentBase entity, byte? value) => DependentBaseUnsafeAccessors.Id(entity) = value); + id.SetAccessors( + byte? (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Id(((CompiledModelTestBase.DependentBase)(entry.Entity))), + byte? (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Id(((CompiledModelTestBase.DependentBase)(entry.Entity))), + byte? (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 3), + byte? (InternalEntityEntry entry) => entry.GetCurrentValue(id), + object (ValueBuffer valueBuffer) => valueBuffer[3]); + id.SetPropertyIndexes( + index: 3, + originalValueIndex: 3, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); id.TypeMapping = MySqlByteTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (byte)v1 == (byte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(byte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(byte)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (byte)v1 == (byte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(byte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(byte)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (byte)v1 == (byte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(byte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(byte)v : default(Nullable))); + comparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + keyComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + providerValueComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)); + id.SetComparer(new NullableValueComparer(id.TypeMapping.Comparer)); + id.SetKeyComparer(new NullableValueComparer(id.TypeMapping.KeyComparer)); id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var key = runtimeEntityType.AddKey( @@ -161,6 +228,27 @@ public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEnt propertyInfo: typeof(CompiledModelTestBase.DependentBase).GetProperty("Principal", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.DependentBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + principal.SetGetter( + CompiledModelTestBase.PrincipalDerived> (CompiledModelTestBase.DependentBase entity) => DependentBaseUnsafeAccessors.Principal(entity), + bool (CompiledModelTestBase.DependentBase entity) => DependentBaseUnsafeAccessors.Principal(entity) == null, + CompiledModelTestBase.PrincipalDerived> (CompiledModelTestBase.DependentBase instance) => DependentBaseUnsafeAccessors.Principal(instance), + bool (CompiledModelTestBase.DependentBase instance) => DependentBaseUnsafeAccessors.Principal(instance) == null); + principal.SetSetter( + (CompiledModelTestBase.DependentBase entity, CompiledModelTestBase.PrincipalDerived> value) => DependentBaseUnsafeAccessors.Principal(entity) = value); + principal.SetMaterializationSetter( + (CompiledModelTestBase.DependentBase entity, CompiledModelTestBase.PrincipalDerived> value) => DependentBaseUnsafeAccessors.Principal(entity) = value); + principal.SetAccessors( + CompiledModelTestBase.PrincipalDerived> (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Principal(((CompiledModelTestBase.DependentBase)(entry.Entity))), + CompiledModelTestBase.PrincipalDerived> (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Principal(((CompiledModelTestBase.DependentBase)(entry.Entity))), + null, + CompiledModelTestBase.PrincipalDerived> (InternalEntityEntry entry) => entry.GetCurrentValue>>(principal), + null); + principal.SetPropertyIndexes( + index: 0, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 2, + storeGenerationIndex: -1); var dependent = principalEntityType.AddNavigation("Dependent", runtimeForeignKey, onDependent: false, @@ -170,11 +258,68 @@ public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEnt eagerLoaded: true, lazyLoadingEnabled: false); + dependent.SetGetter( + CompiledModelTestBase.DependentBase (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Dependent(entity), + bool (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Dependent(entity) == null, + CompiledModelTestBase.DependentBase (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.Dependent(instance), + bool (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.Dependent(instance) == null); + dependent.SetSetter( + (CompiledModelTestBase.PrincipalDerived> entity, CompiledModelTestBase.DependentBase value) => PrincipalDerivedUnsafeAccessors>.Dependent(entity) = value); + dependent.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalDerived> entity, CompiledModelTestBase.DependentBase value) => PrincipalDerivedUnsafeAccessors>.Dependent(entity) = value); + dependent.SetAccessors( + CompiledModelTestBase.DependentBase (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.Dependent(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + CompiledModelTestBase.DependentBase (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.Dependent(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + null, + CompiledModelTestBase.DependentBase (InternalEntityEntry entry) => entry.GetCurrentValue>(dependent), + null); + dependent.SetPropertyIndexes( + index: 2, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 4, + storeGenerationIndex: -1); return runtimeForeignKey; } public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var principalId = runtimeEntityType.FindProperty("PrincipalId"); + var principalAlternateId = runtimeEntityType.FindProperty("PrincipalAlternateId"); + var enumDiscriminator = runtimeEntityType.FindProperty("EnumDiscriminator"); + var id = runtimeEntityType.FindProperty("Id"); + var key = runtimeEntityType.FindKey(new[] { principalId, principalAlternateId }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateCompositeFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory>(key)); + var principal = runtimeEntityType.FindNavigation("Principal"); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.DependentBase)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalId)), ((ValueComparer)(((IProperty)principalAlternateId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalAlternateId)), ((ValueComparer)(((IProperty)enumDiscriminator).GetValueComparer())).Snapshot(source.GetCurrentValue(enumDiscriminator)), (source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id)))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalId).GetValueComparer())).Snapshot(default(long)), ((ValueComparer)(((IProperty)principalAlternateId).GetValueComparer())).Snapshot(default(Guid)))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(long), default(Guid))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("PrincipalId") ? ((long)(source["PrincipalId"])) : 0L), (source.ContainsKey("PrincipalAlternateId") ? ((Guid)(source["PrincipalAlternateId"])) : new Guid("00000000-0000-0000-0000-000000000000")), (source.ContainsKey("EnumDiscriminator") ? ((CompiledModelTestBase.Enum1)(source["EnumDiscriminator"])) : CompiledModelTestBase.Enum1.Default))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(long), default(Guid), default(CompiledModelTestBase.Enum1))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.DependentBase)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalId)), ((ValueComparer)(((IProperty)principalAlternateId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalAlternateId)), DependentBaseUnsafeAccessors.Principal(entity)))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 4, + navigationCount: 1, + complexPropertyCount: 0, + originalValueCount: 4, + shadowCount: 3, + relationshipCount: 3, + storeGeneratedCount: 2); runtimeEntityType.AddAnnotation("DiscriminatorMappingComplete", false); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:MappingStrategy", "TPH"); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentBaseUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentBaseUnsafeAccessors.cs new file mode 100644 index 000000000..d7a27e947 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentBaseUnsafeAccessors.cs @@ -0,0 +1,18 @@ +// +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DependentBaseUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TKey Id(CompiledModelTestBase.DependentBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.PrincipalDerived> Principal(CompiledModelTestBase.DependentBase @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentDerivedEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentDerivedEntityType.cs index 6bdeb8f9c..8b0d2a5e0 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentDerivedEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentDerivedEntityType.cs @@ -1,8 +1,12 @@ // using System; +using System.Collections.Generic; using System.Reflection; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; using Microsoft.EntityFrameworkCore.Storage; using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; @@ -12,7 +16,8 @@ namespace TestNamespace { - internal partial class DependentDerivedEntityType + [EntityFrameworkInternal] + public partial class DependentDerivedEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -32,19 +37,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas nullable: true, maxLength: 20, unicode: false); + data.SetGetter( + string (CompiledModelTestBase.DependentDerived entity) => DependentDerivedUnsafeAccessors.Data(entity), + bool (CompiledModelTestBase.DependentDerived entity) => DependentDerivedUnsafeAccessors.Data(entity) == null, + string (CompiledModelTestBase.DependentDerived instance) => DependentDerivedUnsafeAccessors.Data(instance), + bool (CompiledModelTestBase.DependentDerived instance) => DependentDerivedUnsafeAccessors.Data(instance) == null); + data.SetSetter( + (CompiledModelTestBase.DependentDerived entity, string value) => DependentDerivedUnsafeAccessors.Data(entity) = value); + data.SetMaterializationSetter( + (CompiledModelTestBase.DependentDerived entity, string value) => DependentDerivedUnsafeAccessors.Data(entity) = value); + data.SetAccessors( + string (InternalEntityEntry entry) => DependentDerivedUnsafeAccessors.Data(((CompiledModelTestBase.DependentDerived)(entry.Entity))), + string (InternalEntityEntry entry) => DependentDerivedUnsafeAccessors.Data(((CompiledModelTestBase.DependentDerived)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(data, 4), + string (InternalEntityEntry entry) => entry.GetCurrentValue(data), + object (ValueBuffer valueBuffer) => valueBuffer[4]); + data.SetPropertyIndexes( + index: 4, + originalValueIndex: 4, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); data.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "char(20)", size: 20, @@ -60,19 +86,31 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas precision: 9, scale: 3, sentinel: 0m); + money.SetAccessors( + decimal (InternalEntityEntry entry) => entry.ReadShadowValue(3), + decimal (InternalEntityEntry entry) => entry.ReadShadowValue(3), + decimal (InternalEntityEntry entry) => entry.ReadOriginalValue(money, 5), + decimal (InternalEntityEntry entry) => entry.GetCurrentValue(money), + object (ValueBuffer valueBuffer) => valueBuffer[5]); + money.SetPropertyIndexes( + index: 5, + originalValueIndex: 5, + shadowIndex: 3, + relationshipIndex: -1, + storeGenerationIndex: -1); money.TypeMapping = MySqlDecimalTypeMapping.Default.Clone( comparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), keyComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), providerValueComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "decimal(9,3)", precision: 9, @@ -84,6 +122,41 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var principalId = runtimeEntityType.FindProperty("PrincipalId"); + var principalAlternateId = runtimeEntityType.FindProperty("PrincipalAlternateId"); + var enumDiscriminator = runtimeEntityType.FindProperty("EnumDiscriminator"); + var id = runtimeEntityType.FindProperty("Id"); + var data = runtimeEntityType.FindProperty("Data"); + var money = runtimeEntityType.FindProperty("Money"); + var principal = runtimeEntityType.FindNavigation("Principal"); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.DependentDerived)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalId)), ((ValueComparer)(((IProperty)principalAlternateId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalAlternateId)), ((ValueComparer)(((IProperty)enumDiscriminator).GetValueComparer())).Snapshot(source.GetCurrentValue(enumDiscriminator)), (source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id))), (source.GetCurrentValue(data) == null ? null : ((ValueComparer)(((IProperty)data).GetValueComparer())).Snapshot(source.GetCurrentValue(data))), ((ValueComparer)(((IProperty)money).GetValueComparer())).Snapshot(source.GetCurrentValue(money))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalId).GetValueComparer())).Snapshot(default(long)), ((ValueComparer)(((IProperty)principalAlternateId).GetValueComparer())).Snapshot(default(Guid)))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(long), default(Guid))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("PrincipalId") ? ((long)(source["PrincipalId"])) : 0L), (source.ContainsKey("PrincipalAlternateId") ? ((Guid)(source["PrincipalAlternateId"])) : new Guid("00000000-0000-0000-0000-000000000000")), (source.ContainsKey("EnumDiscriminator") ? ((CompiledModelTestBase.Enum1)(source["EnumDiscriminator"])) : CompiledModelTestBase.Enum1.Default), (source.ContainsKey("Money") ? ((decimal)(source["Money"])) : 0M))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(long), default(Guid), default(CompiledModelTestBase.Enum1), default(decimal))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.DependentDerived)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalId)), ((ValueComparer)(((IProperty)principalAlternateId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalAlternateId)), DependentBaseUnsafeAccessors.Principal(entity7)))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 6, + navigationCount: 1, + complexPropertyCount: 0, + originalValueCount: 6, + shadowCount: 4, + relationshipCount: 3, + storeGeneratedCount: 2); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentDerivedUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentDerivedUnsafeAccessors.cs new file mode 100644 index 000000000..8847446bf --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/DependentDerivedUnsafeAccessors.cs @@ -0,0 +1,16 @@ +// +using System; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DependentDerivedUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string Data(CompiledModelTestBase.DependentDerived @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/ManyTypesEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/ManyTypesEntityType.cs index 4a7879593..020094963 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/ManyTypesEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/ManyTypesEntityType.cs @@ -9,7 +9,10 @@ using System.Reflection; using System.Text; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.Storage.Json; @@ -22,7 +25,8 @@ namespace TestNamespace { - internal partial class ManyTypesEntityType + [EntityFrameworkInternal] + public partial class ManyTypesEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -41,27 +45,49 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueGenerated: ValueGenerated.OnAdd, afterSaveBehavior: PropertySaveBehavior.Throw, valueConverter: new CompiledModelTestBase.ManyTypesIdConverter()); + id.SetGetter( + CompiledModelTestBase.ManyTypesId (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Id(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Id(entity).Equals(default(CompiledModelTestBase.ManyTypesId)), + CompiledModelTestBase.ManyTypesId (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Id(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Id(instance).Equals(default(CompiledModelTestBase.ManyTypesId))); + id.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.ManyTypesId value) => ManyTypesUnsafeAccessors.Id(entity) = value); + id.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.ManyTypesId value) => ManyTypesUnsafeAccessors.Id(entity) = value); + id.SetAccessors( + CompiledModelTestBase.ManyTypesId (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(0) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(0) && ManyTypesUnsafeAccessors.Id(((CompiledModelTestBase.ManyTypes)(entry.Entity))).Equals(default(CompiledModelTestBase.ManyTypesId)) ? entry.ReadTemporaryValue(0) : ManyTypesUnsafeAccessors.Id(((CompiledModelTestBase.ManyTypes)(entry.Entity))))), + CompiledModelTestBase.ManyTypesId (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Id(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.ManyTypesId (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 0), + CompiledModelTestBase.ManyTypesId (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + id.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: -1, + relationshipIndex: 0, + storeGenerationIndex: 0); id.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.ManyTypesId v1, CompiledModelTestBase.ManyTypesId v2) => v1.Equals(v2), - (CompiledModelTestBase.ManyTypesId v) => v.GetHashCode(), - (CompiledModelTestBase.ManyTypesId v) => v), + bool (CompiledModelTestBase.ManyTypesId v1, CompiledModelTestBase.ManyTypesId v2) => v1.Equals(v2), + int (CompiledModelTestBase.ManyTypesId v) => ((object)v).GetHashCode(), + CompiledModelTestBase.ManyTypesId (CompiledModelTestBase.ManyTypesId v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.ManyTypesId v1, CompiledModelTestBase.ManyTypesId v2) => v1.Equals(v2), - (CompiledModelTestBase.ManyTypesId v) => v.GetHashCode(), - (CompiledModelTestBase.ManyTypesId v) => v), + bool (CompiledModelTestBase.ManyTypesId v1, CompiledModelTestBase.ManyTypesId v2) => v1.Equals(v2), + int (CompiledModelTestBase.ManyTypesId v) => ((object)v).GetHashCode(), + CompiledModelTestBase.ManyTypesId (CompiledModelTestBase.ManyTypesId v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.ManyTypesId v) => v.Id, - (int v) => new CompiledModelTestBase.ManyTypesId(v)), + int (CompiledModelTestBase.ManyTypesId v) => v.Id, + CompiledModelTestBase.ManyTypesId (int v) => new CompiledModelTestBase.ManyTypesId(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.ManyTypesId v) => v.Id, - (int v) => new CompiledModelTestBase.ManyTypesId(v)))); + int (CompiledModelTestBase.ManyTypesId v) => v.Id, + CompiledModelTestBase.ManyTypesId (int v) => new CompiledModelTestBase.ManyTypesId(v)))); + id.SetCurrentValueComparer(new CurrentProviderValueComparer(id)); id.SetSentinelFromProviderValue(0); id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); @@ -71,19 +97,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Bool", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: false); + @bool.SetGetter( + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Bool(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Bool(entity) == false, + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Bool(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Bool(instance) == false); + @bool.SetSetter( + (CompiledModelTestBase.ManyTypes entity, bool value) => ManyTypesUnsafeAccessors.Bool(entity) = value); + @bool.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, bool value) => ManyTypesUnsafeAccessors.Bool(entity) = value); + @bool.SetAccessors( + bool (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Bool(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Bool(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool (InternalEntityEntry entry) => entry.ReadOriginalValue(@bool, 1), + bool (InternalEntityEntry entry) => entry.GetCurrentValue(@bool), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + @bool.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); @bool.TypeMapping = MySqlBoolTypeMapping.Default.Clone( comparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), keyComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), providerValueComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v)); + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v)); @bool.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var boolArray = runtimeEntityType.AddProperty( @@ -91,39 +138,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(bool[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BoolArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + boolArray.SetGetter( + bool[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BoolArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BoolArray(entity) == null, + bool[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BoolArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BoolArray(instance) == null); + boolArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, bool[] value) => ManyTypesUnsafeAccessors.BoolArray(entity) = value); + boolArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, bool[] value) => ManyTypesUnsafeAccessors.BoolArray(entity) = value); + boolArray.SetAccessors( + bool[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BoolArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BoolArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool[] (InternalEntityEntry entry) => entry.ReadOriginalValue(boolArray, 2), + bool[] (InternalEntityEntry entry) => entry.GetCurrentValue(boolArray), + object (ValueBuffer valueBuffer) => valueBuffer[2]); + boolArray.SetPropertyIndexes( + index: 2, + originalValueIndex: 2, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); boolArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonBoolReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonBoolReaderWriter.Instance), elementMapping: MySqlBoolTypeMapping.Default.Clone( comparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), keyComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), providerValueComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v))); + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v))); boolArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var boolToStringConverterProperty = runtimeEntityType.AddProperty( @@ -131,30 +199,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(bool), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BoolToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + boolToStringConverterProperty.SetGetter( + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BoolToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BoolToStringConverterProperty(entity) == false, + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BoolToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BoolToStringConverterProperty(instance) == false); + boolToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, bool value) => ManyTypesUnsafeAccessors.BoolToStringConverterProperty(entity) = value); + boolToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, bool value) => ManyTypesUnsafeAccessors.BoolToStringConverterProperty(entity) = value); + boolToStringConverterProperty.SetAccessors( + bool (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BoolToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BoolToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool (InternalEntityEntry entry) => entry.ReadOriginalValue(boolToStringConverterProperty, 3), + bool (InternalEntityEntry entry) => entry.GetCurrentValue(boolToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[3]); + boolToStringConverterProperty.SetPropertyIndexes( + index: 3, + originalValueIndex: 3, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); boolToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), keyComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(1)", size: 1), converter: new ValueConverter( - (bool v) => (string)(v ? "B" : "A"), - (string v) => !string.IsNullOrEmpty(v) && (int)v.ToUpperInvariant()[0] == (int)'B'), + string (bool v) => ((string)((v ? "B" : "A"))), + bool (string v) => !(string.IsNullOrEmpty(v)) && ((int)(v.ToUpperInvariant()[0])) == ((int)("B".ToUpperInvariant()[0]))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (bool v) => (string)(v ? "B" : "A"), - (string v) => !string.IsNullOrEmpty(v) && (int)v.ToUpperInvariant()[0] == (int)'B'))); + string (bool v) => ((string)((v ? "B" : "A"))), + bool (string v) => !(string.IsNullOrEmpty(v)) && ((int)(v.ToUpperInvariant()[0])) == ((int)("B".ToUpperInvariant()[0]))))); boolToStringConverterProperty.SetSentinelFromProviderValue("A"); boolToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -163,27 +252,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(bool), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BoolToTwoValuesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + boolToTwoValuesConverterProperty.SetGetter( + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BoolToTwoValuesConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BoolToTwoValuesConverterProperty(entity) == false, + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BoolToTwoValuesConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BoolToTwoValuesConverterProperty(instance) == false); + boolToTwoValuesConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, bool value) => ManyTypesUnsafeAccessors.BoolToTwoValuesConverterProperty(entity) = value); + boolToTwoValuesConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, bool value) => ManyTypesUnsafeAccessors.BoolToTwoValuesConverterProperty(entity) = value); + boolToTwoValuesConverterProperty.SetAccessors( + bool (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BoolToTwoValuesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BoolToTwoValuesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool (InternalEntityEntry entry) => entry.ReadOriginalValue(boolToTwoValuesConverterProperty, 4), + bool (InternalEntityEntry entry) => entry.GetCurrentValue(boolToTwoValuesConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[4]); + boolToTwoValuesConverterProperty.SetPropertyIndexes( + index: 4, + originalValueIndex: 4, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); boolToTwoValuesConverterProperty.TypeMapping = MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), keyComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (bool v) => (byte)(v ? 1 : 0), - (byte v) => v == 1), + byte (bool v) => ((byte)((v ? 1 : 0))), + bool (byte v) => v == 1), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (bool v) => (byte)(v ? 1 : 0), - (byte v) => v == 1))); + byte (bool v) => ((byte)((v ? 1 : 0))), + bool (byte v) => v == 1))); boolToTwoValuesConverterProperty.SetSentinelFromProviderValue((byte)0); boolToTwoValuesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -193,27 +303,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BoolToZeroOneConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new BoolToZeroOneConverter()); + boolToZeroOneConverterProperty.SetGetter( + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BoolToZeroOneConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BoolToZeroOneConverterProperty(entity) == false, + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BoolToZeroOneConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BoolToZeroOneConverterProperty(instance) == false); + boolToZeroOneConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, bool value) => ManyTypesUnsafeAccessors.BoolToZeroOneConverterProperty(entity) = value); + boolToZeroOneConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, bool value) => ManyTypesUnsafeAccessors.BoolToZeroOneConverterProperty(entity) = value); + boolToZeroOneConverterProperty.SetAccessors( + bool (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BoolToZeroOneConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BoolToZeroOneConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool (InternalEntityEntry entry) => entry.ReadOriginalValue(boolToZeroOneConverterProperty, 5), + bool (InternalEntityEntry entry) => entry.GetCurrentValue(boolToZeroOneConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[5]); + boolToZeroOneConverterProperty.SetPropertyIndexes( + index: 5, + originalValueIndex: 5, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); boolToZeroOneConverterProperty.TypeMapping = MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), keyComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (bool v) => (short)(v ? 1 : 0), - (short v) => v == 1), + short (bool v) => ((short)((v ? 1 : 0))), + bool (short v) => v == 1), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (bool v) => (short)(v ? 1 : 0), - (short v) => v == 1))); + short (bool v) => ((short)((v ? 1 : 0))), + bool (short v) => v == 1))); boolToZeroOneConverterProperty.SetSentinelFromProviderValue((short)0); boolToZeroOneConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -222,19 +353,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(byte[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Bytes", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + bytes.SetGetter( + byte[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Bytes(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Bytes(entity) == null, + byte[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Bytes(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Bytes(instance) == null); + bytes.SetSetter( + (CompiledModelTestBase.ManyTypes entity, byte[] value) => ManyTypesUnsafeAccessors.Bytes(entity) = value); + bytes.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, byte[] value) => ManyTypesUnsafeAccessors.Bytes(entity) = value); + bytes.SetAccessors( + byte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Bytes(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Bytes(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(bytes, 6), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(bytes), + object (ValueBuffer valueBuffer) => valueBuffer[6]); + bytes.SetPropertyIndexes( + index: 6, + originalValueIndex: 6, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); bytes.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray())); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray())); bytes.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var bytesArray = runtimeEntityType.AddProperty( @@ -242,39 +394,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(byte[][]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BytesArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + bytesArray.SetGetter( + byte[][] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BytesArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BytesArray(entity) == null, + byte[][] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BytesArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BytesArray(instance) == null); + bytesArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, byte[][] value) => ManyTypesUnsafeAccessors.BytesArray(entity) = value); + bytesArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, byte[][] value) => ManyTypesUnsafeAccessors.BytesArray(entity) = value); + bytesArray.SetAccessors( + byte[][] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BytesArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[][] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BytesArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[][] (InternalEntityEntry entry) => entry.ReadOriginalValue(bytesArray, 7), + byte[][] (InternalEntityEntry entry) => entry.GetCurrentValue(bytesArray), + object (ValueBuffer valueBuffer) => valueBuffer[7]); + bytesArray.SetPropertyIndexes( + index: 7, + originalValueIndex: 7, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); bytesArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( JsonByteArrayReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( JsonByteArrayReaderWriter.Instance), elementMapping: MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()))); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()))); bytesArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var bytesToStringConverterProperty = runtimeEntityType.AddProperty( @@ -284,30 +457,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new BytesToStringConverter(), valueComparer: new ArrayStructuralComparer()); + bytesToStringConverterProperty.SetGetter( + byte[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BytesToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.BytesToStringConverterProperty(entity) == null, + byte[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BytesToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.BytesToStringConverterProperty(instance) == null); + bytesToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, byte[] value) => ManyTypesUnsafeAccessors.BytesToStringConverterProperty(entity) = value); + bytesToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, byte[] value) => ManyTypesUnsafeAccessors.BytesToStringConverterProperty(entity) = value); + bytesToStringConverterProperty.SetAccessors( + byte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BytesToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.BytesToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(bytesToStringConverterProperty, 8), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(bytesToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[8]); + bytesToStringConverterProperty.SetPropertyIndexes( + index: 8, + originalValueIndex: 8, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); bytesToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] v) => v.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] v) => v.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (Byte[] v) => Convert.ToBase64String(v), - (string v) => Convert.FromBase64String(v)), + string (byte[] v) => Convert.ToBase64String(v), + byte[] (string v) => Convert.FromBase64String(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Byte[] v) => Convert.ToBase64String(v), - (string v) => Convert.FromBase64String(v)))); + string (byte[] v) => Convert.ToBase64String(v), + byte[] (string v) => Convert.FromBase64String(v)))); bytesToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var castingConverterProperty = runtimeEntityType.AddProperty( @@ -316,27 +510,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("CastingConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new CastingConverter()); + castingConverterProperty.SetGetter( + int (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.CastingConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.CastingConverterProperty(entity) == 0, + int (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.CastingConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.CastingConverterProperty(instance) == 0); + castingConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, int value) => ManyTypesUnsafeAccessors.CastingConverterProperty(entity) = value); + castingConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, int value) => ManyTypesUnsafeAccessors.CastingConverterProperty(entity) = value); + castingConverterProperty.SetAccessors( + int (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.CastingConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.CastingConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(castingConverterProperty, 9), + int (InternalEntityEntry entry) => entry.GetCurrentValue(castingConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[9]); + castingConverterProperty.SetPropertyIndexes( + index: 9, + originalValueIndex: 9, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); castingConverterProperty.TypeMapping = MySqlDecimalTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), converter: new ValueConverter( - (int v) => (decimal)v, - (decimal v) => (int)v), + decimal (int v) => ((decimal)(v)), + int (decimal v) => ((int)(v))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonDecimalReaderWriter.Instance, new ValueConverter( - (int v) => (decimal)v, - (decimal v) => (int)v))); + decimal (int v) => ((decimal)(v)), + int (decimal v) => ((int)(v))))); castingConverterProperty.SetSentinelFromProviderValue(0m); castingConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -345,30 +560,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(char), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Char", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + @char.SetGetter( + char (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Char(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Char(entity) == '\0', + char (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Char(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Char(instance) == '\0'); + @char.SetSetter( + (CompiledModelTestBase.ManyTypes entity, char value) => ManyTypesUnsafeAccessors.Char(entity) = value); + @char.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, char value) => ManyTypesUnsafeAccessors.Char(entity) = value); + @char.SetAccessors( + char (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Char(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Char(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char (InternalEntityEntry entry) => entry.ReadOriginalValue(@char, 10), + char (InternalEntityEntry entry) => entry.GetCurrentValue(@char), + object (ValueBuffer valueBuffer) => valueBuffer[10]); + @char.SetPropertyIndexes( + index: 10, + originalValueIndex: 10, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); @char.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v), + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), keyComparer: new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v), + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(1)", size: 1), converter: new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]), + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]))); + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])))); @char.SetSentinelFromProviderValue("\0"); @char.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -377,58 +613,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(char[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("CharArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + charArray.SetGetter( + char[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.CharArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.CharArray(entity) == null, + char[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.CharArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.CharArray(instance) == null); + charArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, char[] value) => ManyTypesUnsafeAccessors.CharArray(entity) = value); + charArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, char[] value) => ManyTypesUnsafeAccessors.CharArray(entity) = value); + charArray.SetAccessors( + char[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.CharArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.CharArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char[] (InternalEntityEntry entry) => entry.ReadOriginalValue(charArray, 11), + char[] (InternalEntityEntry entry) => entry.GetCurrentValue(charArray), + object (ValueBuffer valueBuffer) => valueBuffer[11]); + charArray.SetPropertyIndexes( + index: 11, + originalValueIndex: 11, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); charArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0])))), + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0]))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]))), + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v), + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), keyComparer: new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v), + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(1)", size: 1), converter: new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]), + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0])))); + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0]))))); charArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var charToStringConverterProperty = runtimeEntityType.AddProperty( @@ -437,30 +694,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("CharToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new CharToStringConverter()); + charToStringConverterProperty.SetGetter( + char (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.CharToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.CharToStringConverterProperty(entity) == '\0', + char (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.CharToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.CharToStringConverterProperty(instance) == '\0'); + charToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, char value) => ManyTypesUnsafeAccessors.CharToStringConverterProperty(entity) = value); + charToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, char value) => ManyTypesUnsafeAccessors.CharToStringConverterProperty(entity) = value); + charToStringConverterProperty.SetAccessors( + char (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.CharToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.CharToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char (InternalEntityEntry entry) => entry.ReadOriginalValue(charToStringConverterProperty, 12), + char (InternalEntityEntry entry) => entry.GetCurrentValue(charToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[12]); + charToStringConverterProperty.SetPropertyIndexes( + index: 12, + originalValueIndex: 12, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); charToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v), + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), keyComparer: new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v), + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(1)", size: 1), converter: new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]), + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]))); + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])))); charToStringConverterProperty.SetSentinelFromProviderValue("\0"); charToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -470,19 +748,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateOnly", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: new DateOnly(1, 1, 1)); + dateOnly.SetGetter( + DateOnly (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateOnly(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateOnly(entity) == default(DateOnly), + DateOnly (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateOnly(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateOnly(instance) == default(DateOnly)); + dateOnly.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly value) => ManyTypesUnsafeAccessors.DateOnly(entity) = value); + dateOnly.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly value) => ManyTypesUnsafeAccessors.DateOnly(entity) = value); + dateOnly.SetAccessors( + DateOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateOnly(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateOnly(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly (InternalEntityEntry entry) => entry.ReadOriginalValue(dateOnly, 13), + DateOnly (InternalEntityEntry entry) => entry.GetCurrentValue(dateOnly), + object (ValueBuffer valueBuffer) => valueBuffer[13]); + dateOnly.SetPropertyIndexes( + index: 13, + originalValueIndex: 13, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateOnly.TypeMapping = MySqlDateTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v), + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), keyComparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v), + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), providerValueComparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v)); + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v)); dateOnly.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var dateOnlyArray = runtimeEntityType.AddProperty( @@ -490,39 +789,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(DateOnly[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateOnlyArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + dateOnlyArray.SetGetter( + DateOnly[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateOnlyArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateOnlyArray(entity) == null, + DateOnly[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateOnlyArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateOnlyArray(instance) == null); + dateOnlyArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly[] value) => ManyTypesUnsafeAccessors.DateOnlyArray(entity) = value); + dateOnlyArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly[] value) => ManyTypesUnsafeAccessors.DateOnlyArray(entity) = value); + dateOnlyArray.SetAccessors( + DateOnly[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateOnlyArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateOnlyArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly[] (InternalEntityEntry entry) => entry.ReadOriginalValue(dateOnlyArray, 14), + DateOnly[] (InternalEntityEntry entry) => entry.GetCurrentValue(dateOnlyArray), + object (ValueBuffer valueBuffer) => valueBuffer[14]); + dateOnlyArray.SetPropertyIndexes( + index: 14, + originalValueIndex: 14, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateOnlyArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonDateOnlyReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonDateOnlyReaderWriter.Instance), elementMapping: MySqlDateTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v), + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), keyComparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v), + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), providerValueComparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v))); + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v))); dateOnlyArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var dateOnlyToStringConverterProperty = runtimeEntityType.AddProperty( @@ -531,30 +851,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateOnlyToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new DateOnlyToStringConverter()); + dateOnlyToStringConverterProperty.SetGetter( + DateOnly (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateOnlyToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateOnlyToStringConverterProperty(entity) == default(DateOnly), + DateOnly (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateOnlyToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateOnlyToStringConverterProperty(instance) == default(DateOnly)); + dateOnlyToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly value) => ManyTypesUnsafeAccessors.DateOnlyToStringConverterProperty(entity) = value); + dateOnlyToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly value) => ManyTypesUnsafeAccessors.DateOnlyToStringConverterProperty(entity) = value); + dateOnlyToStringConverterProperty.SetAccessors( + DateOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateOnlyToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateOnlyToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly (InternalEntityEntry entry) => entry.ReadOriginalValue(dateOnlyToStringConverterProperty, 15), + DateOnly (InternalEntityEntry entry) => entry.GetCurrentValue(dateOnlyToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[15]); + dateOnlyToStringConverterProperty.SetPropertyIndexes( + index: 15, + originalValueIndex: 15, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateOnlyToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v), + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), keyComparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v), + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(10)", size: 10), converter: new ValueConverter( - (DateOnly v) => v.ToString("yyyy\\-MM\\-dd"), - (string v) => DateOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None)), + string (DateOnly v) => v.ToString("yyyy\\-MM\\-dd"), + DateOnly (string v) => DateOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (DateOnly v) => v.ToString("yyyy\\-MM\\-dd"), - (string v) => DateOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None)))); + string (DateOnly v) => v.ToString("yyyy\\-MM\\-dd"), + DateOnly (string v) => DateOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None)))); dateOnlyToStringConverterProperty.SetSentinelFromProviderValue("0001-01-01"); dateOnlyToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -564,19 +905,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTime", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified)); + dateTime.SetGetter( + DateTime (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTime(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTime(entity) == default(DateTime), + DateTime (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTime(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTime(instance) == default(DateTime)); + dateTime.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime value) => ManyTypesUnsafeAccessors.DateTime(entity) = value); + dateTime.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime value) => ManyTypesUnsafeAccessors.DateTime(entity) = value); + dateTime.SetAccessors( + DateTime (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTime(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTime(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime (InternalEntityEntry entry) => entry.ReadOriginalValue(dateTime, 16), + DateTime (InternalEntityEntry entry) => entry.GetCurrentValue(dateTime), + object (ValueBuffer valueBuffer) => valueBuffer[16]); + dateTime.SetPropertyIndexes( + index: 16, + originalValueIndex: 16, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateTime.TypeMapping = MySqlDateTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), keyComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), providerValueComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", precision: 6)); @@ -587,39 +949,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(DateTime[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + dateTimeArray.SetGetter( + DateTime[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeArray(entity) == null, + DateTime[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeArray(instance) == null); + dateTimeArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime[] value) => ManyTypesUnsafeAccessors.DateTimeArray(entity) = value); + dateTimeArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime[] value) => ManyTypesUnsafeAccessors.DateTimeArray(entity) = value); + dateTimeArray.SetAccessors( + DateTime[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => entry.ReadOriginalValue(dateTimeArray, 17), + DateTime[] (InternalEntityEntry entry) => entry.GetCurrentValue(dateTimeArray), + object (ValueBuffer valueBuffer) => valueBuffer[17]); + dateTimeArray.SetPropertyIndexes( + index: 17, + originalValueIndex: 17, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateTimeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonDateTimeReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonDateTimeReaderWriter.Instance), elementMapping: MySqlDateTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), keyComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), providerValueComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", precision: 6))); @@ -631,27 +1014,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeOffsetToBinaryConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new DateTimeOffsetToBinaryConverter()); + dateTimeOffsetToBinaryConverterProperty.SetGetter( + DateTimeOffset (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeOffsetToBinaryConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeOffsetToBinaryConverterProperty(entity).EqualsExact(default(DateTimeOffset)), + DateTimeOffset (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeOffsetToBinaryConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeOffsetToBinaryConverterProperty(instance).EqualsExact(default(DateTimeOffset))); + dateTimeOffsetToBinaryConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTimeOffset value) => ManyTypesUnsafeAccessors.DateTimeOffsetToBinaryConverterProperty(entity) = value); + dateTimeOffsetToBinaryConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTimeOffset value) => ManyTypesUnsafeAccessors.DateTimeOffsetToBinaryConverterProperty(entity) = value); + dateTimeOffsetToBinaryConverterProperty.SetAccessors( + DateTimeOffset (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeOffsetToBinaryConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTimeOffset (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeOffsetToBinaryConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTimeOffset (InternalEntityEntry entry) => entry.ReadOriginalValue(dateTimeOffsetToBinaryConverterProperty, 18), + DateTimeOffset (InternalEntityEntry entry) => entry.GetCurrentValue(dateTimeOffsetToBinaryConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[18]); + dateTimeOffsetToBinaryConverterProperty.SetPropertyIndexes( + index: 18, + originalValueIndex: 18, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateTimeOffsetToBinaryConverterProperty.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), - (DateTimeOffset v) => v.GetHashCode(), - (DateTimeOffset v) => v), + bool (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), + int (DateTimeOffset v) => ((object)v).GetHashCode(), + DateTimeOffset (DateTimeOffset v) => v), keyComparer: new ValueComparer( - (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), - (DateTimeOffset v) => v.GetHashCode(), - (DateTimeOffset v) => v), + bool (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), + int (DateTimeOffset v) => ((object)v).GetHashCode(), + DateTimeOffset (DateTimeOffset v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (DateTimeOffset v) => DateTimeOffsetToBinaryConverter.ToLong(v), - (long v) => DateTimeOffsetToBinaryConverter.ToDateTimeOffset(v)), + long (DateTimeOffset v) => DateTimeOffsetToBinaryConverter.ToLong(v), + DateTimeOffset (long v) => DateTimeOffsetToBinaryConverter.ToDateTimeOffset(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (DateTimeOffset v) => DateTimeOffsetToBinaryConverter.ToLong(v), - (long v) => DateTimeOffsetToBinaryConverter.ToDateTimeOffset(v)))); + long (DateTimeOffset v) => DateTimeOffsetToBinaryConverter.ToLong(v), + DateTimeOffset (long v) => DateTimeOffsetToBinaryConverter.ToDateTimeOffset(v)))); dateTimeOffsetToBinaryConverterProperty.SetSentinelFromProviderValue(0L); dateTimeOffsetToBinaryConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -661,31 +1065,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeOffsetToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new DateTimeOffsetToBytesConverter()); + dateTimeOffsetToBytesConverterProperty.SetGetter( + DateTimeOffset (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeOffsetToBytesConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeOffsetToBytesConverterProperty(entity).EqualsExact(default(DateTimeOffset)), + DateTimeOffset (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeOffsetToBytesConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeOffsetToBytesConverterProperty(instance).EqualsExact(default(DateTimeOffset))); + dateTimeOffsetToBytesConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTimeOffset value) => ManyTypesUnsafeAccessors.DateTimeOffsetToBytesConverterProperty(entity) = value); + dateTimeOffsetToBytesConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTimeOffset value) => ManyTypesUnsafeAccessors.DateTimeOffsetToBytesConverterProperty(entity) = value); + dateTimeOffsetToBytesConverterProperty.SetAccessors( + DateTimeOffset (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeOffsetToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTimeOffset (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeOffsetToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTimeOffset (InternalEntityEntry entry) => entry.ReadOriginalValue(dateTimeOffsetToBytesConverterProperty, 19), + DateTimeOffset (InternalEntityEntry entry) => entry.GetCurrentValue(dateTimeOffsetToBytesConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[19]); + dateTimeOffsetToBytesConverterProperty.SetPropertyIndexes( + index: 19, + originalValueIndex: 19, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateTimeOffsetToBytesConverterProperty.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), - (DateTimeOffset v) => v.GetHashCode(), - (DateTimeOffset v) => v), + bool (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), + int (DateTimeOffset v) => ((object)v).GetHashCode(), + DateTimeOffset (DateTimeOffset v) => v), keyComparer: new ValueComparer( - (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), - (DateTimeOffset v) => v.GetHashCode(), - (DateTimeOffset v) => v), + bool (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), + int (DateTimeOffset v) => ((object)v).GetHashCode(), + DateTimeOffset (DateTimeOffset v) => v), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varbinary(12)", size: 12), converter: new ValueConverter( - (DateTimeOffset v) => DateTimeOffsetToBytesConverter.ToBytes(v), - (Byte[] v) => DateTimeOffsetToBytesConverter.FromBytes(v)), + byte[] (DateTimeOffset v) => DateTimeOffsetToBytesConverter.ToBytes(v), + DateTimeOffset (byte[] v) => DateTimeOffsetToBytesConverter.FromBytes(v)), storeTypePostfix: StoreTypePostfix.Size, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteArrayReaderWriter.Instance, new ValueConverter( - (DateTimeOffset v) => DateTimeOffsetToBytesConverter.ToBytes(v), - (Byte[] v) => DateTimeOffsetToBytesConverter.FromBytes(v)))); + byte[] (DateTimeOffset v) => DateTimeOffsetToBytesConverter.ToBytes(v), + DateTimeOffset (byte[] v) => DateTimeOffsetToBytesConverter.FromBytes(v)))); dateTimeOffsetToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); dateTimeOffsetToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -695,30 +1120,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeOffsetToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new DateTimeOffsetToStringConverter()); + dateTimeOffsetToStringConverterProperty.SetGetter( + DateTimeOffset (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeOffsetToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeOffsetToStringConverterProperty(entity).EqualsExact(default(DateTimeOffset)), + DateTimeOffset (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeOffsetToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeOffsetToStringConverterProperty(instance).EqualsExact(default(DateTimeOffset))); + dateTimeOffsetToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTimeOffset value) => ManyTypesUnsafeAccessors.DateTimeOffsetToStringConverterProperty(entity) = value); + dateTimeOffsetToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTimeOffset value) => ManyTypesUnsafeAccessors.DateTimeOffsetToStringConverterProperty(entity) = value); + dateTimeOffsetToStringConverterProperty.SetAccessors( + DateTimeOffset (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeOffsetToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTimeOffset (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeOffsetToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTimeOffset (InternalEntityEntry entry) => entry.ReadOriginalValue(dateTimeOffsetToStringConverterProperty, 20), + DateTimeOffset (InternalEntityEntry entry) => entry.GetCurrentValue(dateTimeOffsetToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[20]); + dateTimeOffsetToStringConverterProperty.SetPropertyIndexes( + index: 20, + originalValueIndex: 20, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateTimeOffsetToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), - (DateTimeOffset v) => v.GetHashCode(), - (DateTimeOffset v) => v), + bool (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), + int (DateTimeOffset v) => ((object)v).GetHashCode(), + DateTimeOffset (DateTimeOffset v) => v), keyComparer: new ValueComparer( - (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), - (DateTimeOffset v) => v.GetHashCode(), - (DateTimeOffset v) => v), + bool (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), + int (DateTimeOffset v) => ((object)v).GetHashCode(), + DateTimeOffset (DateTimeOffset v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(48)", size: 48), converter: new ValueConverter( - (DateTimeOffset v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFFzzz"), - (string v) => DateTimeOffset.Parse(v, CultureInfo.InvariantCulture)), + string (DateTimeOffset v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFFzzz"), + DateTimeOffset (string v) => DateTimeOffset.Parse(v, CultureInfo.InvariantCulture)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (DateTimeOffset v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFFzzz"), - (string v) => DateTimeOffset.Parse(v, CultureInfo.InvariantCulture)))); + string (DateTimeOffset v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFFzzz"), + DateTimeOffset (string v) => DateTimeOffset.Parse(v, CultureInfo.InvariantCulture)))); dateTimeOffsetToStringConverterProperty.SetSentinelFromProviderValue("0001-01-01 00:00:00+00:00"); dateTimeOffsetToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -728,27 +1174,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeToBinaryConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new DateTimeToBinaryConverter()); + dateTimeToBinaryConverterProperty.SetGetter( + DateTime (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeToBinaryConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeToBinaryConverterProperty(entity) == default(DateTime), + DateTime (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeToBinaryConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeToBinaryConverterProperty(instance) == default(DateTime)); + dateTimeToBinaryConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime value) => ManyTypesUnsafeAccessors.DateTimeToBinaryConverterProperty(entity) = value); + dateTimeToBinaryConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime value) => ManyTypesUnsafeAccessors.DateTimeToBinaryConverterProperty(entity) = value); + dateTimeToBinaryConverterProperty.SetAccessors( + DateTime (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeToBinaryConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeToBinaryConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime (InternalEntityEntry entry) => entry.ReadOriginalValue(dateTimeToBinaryConverterProperty, 21), + DateTime (InternalEntityEntry entry) => entry.GetCurrentValue(dateTimeToBinaryConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[21]); + dateTimeToBinaryConverterProperty.SetPropertyIndexes( + index: 21, + originalValueIndex: 21, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateTimeToBinaryConverterProperty.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), keyComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (DateTime v) => v.ToBinary(), - (long v) => DateTime.FromBinary(v)), + long (DateTime v) => v.ToBinary(), + DateTime (long v) => DateTime.FromBinary(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (DateTime v) => v.ToBinary(), - (long v) => DateTime.FromBinary(v)))); + long (DateTime v) => v.ToBinary(), + DateTime (long v) => DateTime.FromBinary(v)))); dateTimeToBinaryConverterProperty.SetSentinelFromProviderValue(0L); dateTimeToBinaryConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -758,30 +1225,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new DateTimeToStringConverter()); + dateTimeToStringConverterProperty.SetGetter( + DateTime (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeToStringConverterProperty(entity) == default(DateTime), + DateTime (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeToStringConverterProperty(instance) == default(DateTime)); + dateTimeToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime value) => ManyTypesUnsafeAccessors.DateTimeToStringConverterProperty(entity) = value); + dateTimeToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime value) => ManyTypesUnsafeAccessors.DateTimeToStringConverterProperty(entity) = value); + dateTimeToStringConverterProperty.SetAccessors( + DateTime (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime (InternalEntityEntry entry) => entry.ReadOriginalValue(dateTimeToStringConverterProperty, 22), + DateTime (InternalEntityEntry entry) => entry.GetCurrentValue(dateTimeToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[22]); + dateTimeToStringConverterProperty.SetPropertyIndexes( + index: 22, + originalValueIndex: 22, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateTimeToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), keyComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(48)", size: 48), converter: new ValueConverter( - (DateTime v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFF"), - (string v) => DateTime.Parse(v, CultureInfo.InvariantCulture)), + string (DateTime v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFF"), + DateTime (string v) => DateTime.Parse(v, CultureInfo.InvariantCulture)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (DateTime v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFF"), - (string v) => DateTime.Parse(v, CultureInfo.InvariantCulture)))); + string (DateTime v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFF"), + DateTime (string v) => DateTime.Parse(v, CultureInfo.InvariantCulture)))); dateTimeToStringConverterProperty.SetSentinelFromProviderValue("0001-01-01 00:00:00"); dateTimeToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -791,19 +1279,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeToTicksConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified)); + dateTimeToTicksConverterProperty.SetGetter( + DateTime (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeToTicksConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DateTimeToTicksConverterProperty(entity) == default(DateTime), + DateTime (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeToTicksConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DateTimeToTicksConverterProperty(instance) == default(DateTime)); + dateTimeToTicksConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime value) => ManyTypesUnsafeAccessors.DateTimeToTicksConverterProperty(entity) = value); + dateTimeToTicksConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime value) => ManyTypesUnsafeAccessors.DateTimeToTicksConverterProperty(entity) = value); + dateTimeToTicksConverterProperty.SetAccessors( + DateTime (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeToTicksConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DateTimeToTicksConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime (InternalEntityEntry entry) => entry.ReadOriginalValue(dateTimeToTicksConverterProperty, 23), + DateTime (InternalEntityEntry entry) => entry.GetCurrentValue(dateTimeToTicksConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[23]); + dateTimeToTicksConverterProperty.SetPropertyIndexes( + index: 23, + originalValueIndex: 23, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); dateTimeToTicksConverterProperty.TypeMapping = MySqlDateTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), keyComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), providerValueComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", precision: 6)); @@ -815,19 +1324,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Decimal", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: 0m); + @decimal.SetGetter( + decimal (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Decimal(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Decimal(entity) == 0M, + decimal (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Decimal(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Decimal(instance) == 0M); + @decimal.SetSetter( + (CompiledModelTestBase.ManyTypes entity, decimal value) => ManyTypesUnsafeAccessors.Decimal(entity) = value); + @decimal.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, decimal value) => ManyTypesUnsafeAccessors.Decimal(entity) = value); + @decimal.SetAccessors( + decimal (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Decimal(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Decimal(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal (InternalEntityEntry entry) => entry.ReadOriginalValue(@decimal, 24), + decimal (InternalEntityEntry entry) => entry.GetCurrentValue(@decimal), + object (ValueBuffer valueBuffer) => valueBuffer[24]); + @decimal.SetPropertyIndexes( + index: 24, + originalValueIndex: 24, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); @decimal.TypeMapping = MySqlDecimalTypeMapping.Default.Clone( comparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), keyComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), providerValueComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v)); + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v)); @decimal.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var decimalArray = runtimeEntityType.AddProperty( @@ -835,39 +1365,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(decimal[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DecimalArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + decimalArray.SetGetter( + decimal[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DecimalArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DecimalArray(entity) == null, + decimal[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DecimalArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DecimalArray(instance) == null); + decimalArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, decimal[] value) => ManyTypesUnsafeAccessors.DecimalArray(entity) = value); + decimalArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, decimal[] value) => ManyTypesUnsafeAccessors.DecimalArray(entity) = value); + decimalArray.SetAccessors( + decimal[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DecimalArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DecimalArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal[] (InternalEntityEntry entry) => entry.ReadOriginalValue(decimalArray, 25), + decimal[] (InternalEntityEntry entry) => entry.GetCurrentValue(decimalArray), + object (ValueBuffer valueBuffer) => valueBuffer[25]); + decimalArray.SetPropertyIndexes( + index: 25, + originalValueIndex: 25, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); decimalArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonDecimalReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonDecimalReaderWriter.Instance), elementMapping: MySqlDecimalTypeMapping.Default.Clone( comparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), keyComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), providerValueComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v))); + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v))); decimalArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var decimalNumberToBytesConverterProperty = runtimeEntityType.AddProperty( @@ -876,31 +1427,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DecimalNumberToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new NumberToBytesConverter()); + decimalNumberToBytesConverterProperty.SetGetter( + decimal (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DecimalNumberToBytesConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DecimalNumberToBytesConverterProperty(entity) == 0M, + decimal (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DecimalNumberToBytesConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DecimalNumberToBytesConverterProperty(instance) == 0M); + decimalNumberToBytesConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, decimal value) => ManyTypesUnsafeAccessors.DecimalNumberToBytesConverterProperty(entity) = value); + decimalNumberToBytesConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, decimal value) => ManyTypesUnsafeAccessors.DecimalNumberToBytesConverterProperty(entity) = value); + decimalNumberToBytesConverterProperty.SetAccessors( + decimal (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DecimalNumberToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DecimalNumberToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal (InternalEntityEntry entry) => entry.ReadOriginalValue(decimalNumberToBytesConverterProperty, 26), + decimal (InternalEntityEntry entry) => entry.GetCurrentValue(decimalNumberToBytesConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[26]); + decimalNumberToBytesConverterProperty.SetPropertyIndexes( + index: 26, + originalValueIndex: 26, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); decimalNumberToBytesConverterProperty.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), keyComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varbinary(16)", size: 16), converter: new ValueConverter( - (decimal v) => NumberToBytesConverter.DecimalToBytes(v), - (Byte[] v) => v == null ? 0M : NumberToBytesConverter.BytesToDecimal(v)), + byte[] (decimal v) => NumberToBytesConverter.DecimalToBytes(v), + decimal (byte[] v) => (v == null ? 0M : NumberToBytesConverter.BytesToDecimal(v))), storeTypePostfix: StoreTypePostfix.Size, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteArrayReaderWriter.Instance, new ValueConverter( - (decimal v) => NumberToBytesConverter.DecimalToBytes(v), - (Byte[] v) => v == null ? 0M : NumberToBytesConverter.BytesToDecimal(v)))); + byte[] (decimal v) => NumberToBytesConverter.DecimalToBytes(v), + decimal (byte[] v) => (v == null ? 0M : NumberToBytesConverter.BytesToDecimal(v))))); decimalNumberToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); decimalNumberToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -910,30 +1482,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DecimalNumberToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new NumberToStringConverter()); + decimalNumberToStringConverterProperty.SetGetter( + decimal (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DecimalNumberToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DecimalNumberToStringConverterProperty(entity) == 0M, + decimal (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DecimalNumberToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DecimalNumberToStringConverterProperty(instance) == 0M); + decimalNumberToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, decimal value) => ManyTypesUnsafeAccessors.DecimalNumberToStringConverterProperty(entity) = value); + decimalNumberToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, decimal value) => ManyTypesUnsafeAccessors.DecimalNumberToStringConverterProperty(entity) = value); + decimalNumberToStringConverterProperty.SetAccessors( + decimal (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DecimalNumberToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DecimalNumberToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal (InternalEntityEntry entry) => entry.ReadOriginalValue(decimalNumberToStringConverterProperty, 27), + decimal (InternalEntityEntry entry) => entry.GetCurrentValue(decimalNumberToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[27]); + decimalNumberToStringConverterProperty.SetPropertyIndexes( + index: 27, + originalValueIndex: 27, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); decimalNumberToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), keyComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(64)", size: 64), converter: new ValueConverter( - (decimal v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => decimal.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)), + string (decimal v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + decimal (string v) => decimal.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (decimal v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => decimal.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)))); + string (decimal v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + decimal (string v) => decimal.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)))); decimalNumberToStringConverterProperty.SetSentinelFromProviderValue("0"); decimalNumberToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -943,19 +1536,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Double", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: 0.0); + @double.SetGetter( + double (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Double(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Double(entity).Equals(0D), + double (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Double(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Double(instance).Equals(0D)); + @double.SetSetter( + (CompiledModelTestBase.ManyTypes entity, double value) => ManyTypesUnsafeAccessors.Double(entity) = value); + @double.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, double value) => ManyTypesUnsafeAccessors.Double(entity) = value); + @double.SetAccessors( + double (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Double(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Double(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double (InternalEntityEntry entry) => entry.ReadOriginalValue(@double, 28), + double (InternalEntityEntry entry) => entry.GetCurrentValue(@double), + object (ValueBuffer valueBuffer) => valueBuffer[28]); + @double.SetPropertyIndexes( + index: 28, + originalValueIndex: 28, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); @double.TypeMapping = MySqlDoubleTypeMapping.Default.Clone( comparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), keyComparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), providerValueComparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v)); + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v)); @double.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var doubleArray = runtimeEntityType.AddProperty( @@ -963,39 +1577,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(double[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DoubleArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + doubleArray.SetGetter( + double[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DoubleArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DoubleArray(entity) == null, + double[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DoubleArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DoubleArray(instance) == null); + doubleArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, double[] value) => ManyTypesUnsafeAccessors.DoubleArray(entity) = value); + doubleArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, double[] value) => ManyTypesUnsafeAccessors.DoubleArray(entity) = value); + doubleArray.SetAccessors( + double[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DoubleArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DoubleArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double[] (InternalEntityEntry entry) => entry.ReadOriginalValue(doubleArray, 29), + double[] (InternalEntityEntry entry) => entry.GetCurrentValue(doubleArray), + object (ValueBuffer valueBuffer) => valueBuffer[29]); + doubleArray.SetPropertyIndexes( + index: 29, + originalValueIndex: 29, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); doubleArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonDoubleReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonDoubleReaderWriter.Instance), elementMapping: MySqlDoubleTypeMapping.Default.Clone( comparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), keyComparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), providerValueComparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v))); + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v))); doubleArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var doubleNumberToBytesConverterProperty = runtimeEntityType.AddProperty( @@ -1004,31 +1639,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DoubleNumberToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new NumberToBytesConverter()); + doubleNumberToBytesConverterProperty.SetGetter( + double (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DoubleNumberToBytesConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DoubleNumberToBytesConverterProperty(entity).Equals(0D), + double (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DoubleNumberToBytesConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DoubleNumberToBytesConverterProperty(instance).Equals(0D)); + doubleNumberToBytesConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, double value) => ManyTypesUnsafeAccessors.DoubleNumberToBytesConverterProperty(entity) = value); + doubleNumberToBytesConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, double value) => ManyTypesUnsafeAccessors.DoubleNumberToBytesConverterProperty(entity) = value); + doubleNumberToBytesConverterProperty.SetAccessors( + double (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DoubleNumberToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DoubleNumberToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double (InternalEntityEntry entry) => entry.ReadOriginalValue(doubleNumberToBytesConverterProperty, 30), + double (InternalEntityEntry entry) => entry.GetCurrentValue(doubleNumberToBytesConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[30]); + doubleNumberToBytesConverterProperty.SetPropertyIndexes( + index: 30, + originalValueIndex: 30, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); doubleNumberToBytesConverterProperty.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), keyComparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varbinary(8)", size: 8), converter: new ValueConverter( - (double v) => NumberToBytesConverter.ReverseLong(BitConverter.GetBytes(v)), - (Byte[] v) => v == null ? 0D : BitConverter.ToDouble(NumberToBytesConverter.ReverseLong(v), 0)), + byte[] (double v) => NumberToBytesConverter.ReverseLong(BitConverter.GetBytes(v)), + double (byte[] v) => (v == null ? 0D : BitConverter.ToDouble(NumberToBytesConverter.ReverseLong(v), 0))), storeTypePostfix: StoreTypePostfix.Size, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteArrayReaderWriter.Instance, new ValueConverter( - (double v) => NumberToBytesConverter.ReverseLong(BitConverter.GetBytes(v)), - (Byte[] v) => v == null ? 0D : BitConverter.ToDouble(NumberToBytesConverter.ReverseLong(v), 0)))); + byte[] (double v) => NumberToBytesConverter.ReverseLong(BitConverter.GetBytes(v)), + double (byte[] v) => (v == null ? 0D : BitConverter.ToDouble(NumberToBytesConverter.ReverseLong(v), 0))))); doubleNumberToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }); doubleNumberToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -1038,30 +1694,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DoubleNumberToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new NumberToStringConverter()); + doubleNumberToStringConverterProperty.SetGetter( + double (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DoubleNumberToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.DoubleNumberToStringConverterProperty(entity).Equals(0D), + double (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DoubleNumberToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.DoubleNumberToStringConverterProperty(instance).Equals(0D)); + doubleNumberToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, double value) => ManyTypesUnsafeAccessors.DoubleNumberToStringConverterProperty(entity) = value); + doubleNumberToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, double value) => ManyTypesUnsafeAccessors.DoubleNumberToStringConverterProperty(entity) = value); + doubleNumberToStringConverterProperty.SetAccessors( + double (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DoubleNumberToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.DoubleNumberToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double (InternalEntityEntry entry) => entry.ReadOriginalValue(doubleNumberToStringConverterProperty, 31), + double (InternalEntityEntry entry) => entry.GetCurrentValue(doubleNumberToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[31]); + doubleNumberToStringConverterProperty.SetPropertyIndexes( + index: 31, + originalValueIndex: 31, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); doubleNumberToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), keyComparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(64)", size: 64), converter: new ValueConverter( - (double v) => string.Format(CultureInfo.InvariantCulture, "{0:R}", (object)v), - (string v) => double.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)), + string (double v) => string.Format(CultureInfo.InvariantCulture, "{0:R}", ((object)(v))), + double (string v) => double.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (double v) => string.Format(CultureInfo.InvariantCulture, "{0:R}", (object)v), - (string v) => double.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)))); + string (double v) => string.Format(CultureInfo.InvariantCulture, "{0:R}", ((object)(v))), + double (string v) => double.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)))); doubleNumberToStringConverterProperty.SetSentinelFromProviderValue("0"); doubleNumberToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -1070,27 +1747,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum16), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16.SetGetter( + CompiledModelTestBase.Enum16 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum16(entity))), ((object)(CompiledModelTestBase.Enum16.Default))), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum16(instance))), ((object)(CompiledModelTestBase.Enum16.Default)))); + enum16.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16 value) => ManyTypesUnsafeAccessors.Enum16(entity) = value); + enum16.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16 value) => ManyTypesUnsafeAccessors.Enum16(entity) = value); + enum16.SetAccessors( + CompiledModelTestBase.Enum16 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16 (InternalEntityEntry entry) => entry.ReadOriginalValue(enum16, 32), + CompiledModelTestBase.Enum16 (InternalEntityEntry entry) => entry.GetCurrentValue(enum16), + object (ValueBuffer valueBuffer) => valueBuffer[32]); + enum16.SetPropertyIndexes( + index: 32, + originalValueIndex: 32, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum16.TypeMapping = MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value))); + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))))); enum16.SetSentinelFromProviderValue((short)0); enum16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -1099,55 +1797,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum16[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16Array.SetGetter( + CompiledModelTestBase.Enum16[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16Array(entity) == null, + CompiledModelTestBase.Enum16[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16Array(instance) == null); + enum16Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16[] value) => ManyTypesUnsafeAccessors.Enum16Array(entity) = value); + enum16Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16[] value) => ManyTypesUnsafeAccessors.Enum16Array(entity) = value); + enum16Array.SetAccessors( + CompiledModelTestBase.Enum16[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enum16Array, 33), + CompiledModelTestBase.Enum16[] (InternalEntityEntry entry) => entry.GetCurrentValue(enum16Array), + object (ValueBuffer valueBuffer) => valueBuffer[33]); + enum16Array.SetPropertyIndexes( + index: 33, + originalValueIndex: 33, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum16Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))))), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))); + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))); enum16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum16AsString = runtimeEntityType.AddProperty( @@ -1156,30 +1875,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), providerPropertyType: typeof(string)); + enum16AsString.SetGetter( + CompiledModelTestBase.Enum16 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum16AsString(entity))), ((object)(CompiledModelTestBase.Enum16.Default))), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum16AsString(instance))), ((object)(CompiledModelTestBase.Enum16.Default)))); + enum16AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16 value) => ManyTypesUnsafeAccessors.Enum16AsString(entity) = value); + enum16AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16 value) => ManyTypesUnsafeAccessors.Enum16AsString(entity) = value); + enum16AsString.SetAccessors( + CompiledModelTestBase.Enum16 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16 (InternalEntityEntry entry) => entry.ReadOriginalValue(enum16AsString, 34), + CompiledModelTestBase.Enum16 (InternalEntityEntry entry) => entry.GetCurrentValue(enum16AsString), + object (ValueBuffer valueBuffer) => valueBuffer[34]); + enum16AsString.SetPropertyIndexes( + index: 34, + originalValueIndex: 34, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum16AsString.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))); + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v)))); enum16AsString.SetSentinelFromProviderValue("Default"); enum16AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -1188,58 +1928,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum16[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16AsStringArray.SetGetter( + CompiledModelTestBase.Enum16[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16AsStringArray(entity) == null, + CompiledModelTestBase.Enum16[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16AsStringArray(instance) == null); + enum16AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16[] value) => ManyTypesUnsafeAccessors.Enum16AsStringArray(entity) = value); + enum16AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16[] value) => ManyTypesUnsafeAccessors.Enum16AsStringArray(entity) = value); + enum16AsStringArray.SetAccessors( + CompiledModelTestBase.Enum16[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enum16AsStringArray, 35), + CompiledModelTestBase.Enum16[] (InternalEntityEntry entry) => entry.GetCurrentValue(enum16AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[35]); + enum16AsStringArray.SetPropertyIndexes( + index: 35, + originalValueIndex: 35, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum16AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v))))); enum16AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum16AsStringCollection = runtimeEntityType.AddProperty( @@ -1247,58 +2008,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16AsStringCollection(instance) == null); + enum16AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum16AsStringCollection(entity) = value); + enum16AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum16AsStringCollection(entity) = value); + enum16AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enum16AsStringCollection, 36), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enum16AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[36]); + enum16AsStringCollection.SetPropertyIndexes( + index: 36, + originalValueIndex: 36, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum16AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum16>(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum16>(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum16>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum16>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum16>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum16>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.Enum16 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum16 (string v) => StringEnumConverter.ConvertToEnum(v))))); enum16AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum16Collection = runtimeEntityType.AddProperty( @@ -1306,55 +2088,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum16Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum16Collection(instance) == null); + enum16Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum16Collection(entity) = value); + enum16Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum16Collection(entity) = value); + enum16Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum16Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enum16Collection, 37), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enum16Collection), + object (ValueBuffer valueBuffer) => valueBuffer[37]); + enum16Collection.SetPropertyIndexes( + index: 37, + originalValueIndex: 37, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum16Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum16>(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum16>(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum16>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum16>( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum16>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum16>( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))))), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))); + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))); enum16Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum32 = runtimeEntityType.AddProperty( @@ -1362,27 +2165,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum32), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32.SetGetter( + CompiledModelTestBase.Enum32 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum32(entity))), ((object)(CompiledModelTestBase.Enum32.Default))), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum32(instance))), ((object)(CompiledModelTestBase.Enum32.Default)))); + enum32.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32 value) => ManyTypesUnsafeAccessors.Enum32(entity) = value); + enum32.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32 value) => ManyTypesUnsafeAccessors.Enum32(entity) = value); + enum32.SetAccessors( + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => entry.ReadOriginalValue(enum32, 38), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => entry.GetCurrentValue(enum32), + object (ValueBuffer valueBuffer) => valueBuffer[38]); + enum32.SetPropertyIndexes( + index: 38, + originalValueIndex: 38, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum32.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))); enum32.SetSentinelFromProviderValue(0); enum32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -1391,55 +2215,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum32[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32Array.SetGetter( + CompiledModelTestBase.Enum32[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32Array(entity) == null, + CompiledModelTestBase.Enum32[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32Array(instance) == null); + enum32Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32[] value) => ManyTypesUnsafeAccessors.Enum32Array(entity) = value); + enum32Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32[] value) => ManyTypesUnsafeAccessors.Enum32Array(entity) = value); + enum32Array.SetAccessors( + CompiledModelTestBase.Enum32[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enum32Array, 39), + CompiledModelTestBase.Enum32[] (InternalEntityEntry entry) => entry.GetCurrentValue(enum32Array), + object (ValueBuffer valueBuffer) => valueBuffer[39]); + enum32Array.SetPropertyIndexes( + index: 39, + originalValueIndex: 39, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum32Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))), elementMapping: MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))); enum32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum32AsString = runtimeEntityType.AddProperty( @@ -1448,30 +2293,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), providerPropertyType: typeof(string)); + enum32AsString.SetGetter( + CompiledModelTestBase.Enum32 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum32AsString(entity))), ((object)(CompiledModelTestBase.Enum32.Default))), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum32AsString(instance))), ((object)(CompiledModelTestBase.Enum32.Default)))); + enum32AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32 value) => ManyTypesUnsafeAccessors.Enum32AsString(entity) = value); + enum32AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32 value) => ManyTypesUnsafeAccessors.Enum32AsString(entity) = value); + enum32AsString.SetAccessors( + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => entry.ReadOriginalValue(enum32AsString, 40), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => entry.GetCurrentValue(enum32AsString), + object (ValueBuffer valueBuffer) => valueBuffer[40]); + enum32AsString.SetPropertyIndexes( + index: 40, + originalValueIndex: 40, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum32AsString.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))); + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v)))); enum32AsString.SetSentinelFromProviderValue("Default"); enum32AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -1480,58 +2346,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum32[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32AsStringArray.SetGetter( + CompiledModelTestBase.Enum32[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32AsStringArray(entity) == null, + CompiledModelTestBase.Enum32[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32AsStringArray(instance) == null); + enum32AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32[] value) => ManyTypesUnsafeAccessors.Enum32AsStringArray(entity) = value); + enum32AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32[] value) => ManyTypesUnsafeAccessors.Enum32AsStringArray(entity) = value); + enum32AsStringArray.SetAccessors( + CompiledModelTestBase.Enum32[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enum32AsStringArray, 41), + CompiledModelTestBase.Enum32[] (InternalEntityEntry entry) => entry.GetCurrentValue(enum32AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[41]); + enum32AsStringArray.SetPropertyIndexes( + index: 41, + originalValueIndex: 41, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum32AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v))))); enum32AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum32AsStringCollection = runtimeEntityType.AddProperty( @@ -1539,58 +2426,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32AsStringCollection(instance) == null); + enum32AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum32AsStringCollection(entity) = value); + enum32AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum32AsStringCollection(entity) = value); + enum32AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enum32AsStringCollection, 42), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enum32AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[42]); + enum32AsStringCollection.SetPropertyIndexes( + index: 42, + originalValueIndex: 42, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum32AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum32>(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum32>(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum32>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum32>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum32>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum32>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v))))); enum32AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum32Collection = runtimeEntityType.AddProperty( @@ -1598,55 +2506,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum32Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum32Collection(instance) == null); + enum32Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum32Collection(entity) = value); + enum32Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum32Collection(entity) = value); + enum32Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum32Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enum32Collection, 43), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enum32Collection), + object (ValueBuffer valueBuffer) => valueBuffer[43]); + enum32Collection.SetPropertyIndexes( + index: 43, + originalValueIndex: 43, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum32Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum32>(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum32>(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum32>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum32>( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum32>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum32>( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))), elementMapping: MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))); enum32Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum64 = runtimeEntityType.AddProperty( @@ -1654,27 +2583,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum64), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64.SetGetter( + CompiledModelTestBase.Enum64 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum64(entity))), ((object)(CompiledModelTestBase.Enum64.Default))), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum64(instance))), ((object)(CompiledModelTestBase.Enum64.Default)))); + enum64.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64 value) => ManyTypesUnsafeAccessors.Enum64(entity) = value); + enum64.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64 value) => ManyTypesUnsafeAccessors.Enum64(entity) = value); + enum64.SetAccessors( + CompiledModelTestBase.Enum64 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64 (InternalEntityEntry entry) => entry.ReadOriginalValue(enum64, 44), + CompiledModelTestBase.Enum64 (InternalEntityEntry entry) => entry.GetCurrentValue(enum64), + object (ValueBuffer valueBuffer) => valueBuffer[44]); + enum64.SetPropertyIndexes( + index: 44, + originalValueIndex: 44, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum64.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value))); + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))))); enum64.SetSentinelFromProviderValue(0L); enum64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -1683,55 +2633,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum64[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64Array.SetGetter( + CompiledModelTestBase.Enum64[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64Array(entity) == null, + CompiledModelTestBase.Enum64[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64Array(instance) == null); + enum64Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64[] value) => ManyTypesUnsafeAccessors.Enum64Array(entity) = value); + enum64Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64[] value) => ManyTypesUnsafeAccessors.Enum64Array(entity) = value); + enum64Array.SetAccessors( + CompiledModelTestBase.Enum64[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enum64Array, 45), + CompiledModelTestBase.Enum64[] (InternalEntityEntry entry) => entry.GetCurrentValue(enum64Array), + object (ValueBuffer valueBuffer) => valueBuffer[45]); + enum64Array.SetPropertyIndexes( + index: 45, + originalValueIndex: 45, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum64Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))))), elementMapping: MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))); + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))); enum64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum64AsString = runtimeEntityType.AddProperty( @@ -1740,30 +2711,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), providerPropertyType: typeof(string)); + enum64AsString.SetGetter( + CompiledModelTestBase.Enum64 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum64AsString(entity))), ((object)(CompiledModelTestBase.Enum64.Default))), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum64AsString(instance))), ((object)(CompiledModelTestBase.Enum64.Default)))); + enum64AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64 value) => ManyTypesUnsafeAccessors.Enum64AsString(entity) = value); + enum64AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64 value) => ManyTypesUnsafeAccessors.Enum64AsString(entity) = value); + enum64AsString.SetAccessors( + CompiledModelTestBase.Enum64 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64 (InternalEntityEntry entry) => entry.ReadOriginalValue(enum64AsString, 46), + CompiledModelTestBase.Enum64 (InternalEntityEntry entry) => entry.GetCurrentValue(enum64AsString), + object (ValueBuffer valueBuffer) => valueBuffer[46]); + enum64AsString.SetPropertyIndexes( + index: 46, + originalValueIndex: 46, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum64AsString.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))); + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v)))); enum64AsString.SetSentinelFromProviderValue("Default"); enum64AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -1772,58 +2764,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum64[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64AsStringArray.SetGetter( + CompiledModelTestBase.Enum64[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64AsStringArray(entity) == null, + CompiledModelTestBase.Enum64[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64AsStringArray(instance) == null); + enum64AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64[] value) => ManyTypesUnsafeAccessors.Enum64AsStringArray(entity) = value); + enum64AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64[] value) => ManyTypesUnsafeAccessors.Enum64AsStringArray(entity) = value); + enum64AsStringArray.SetAccessors( + CompiledModelTestBase.Enum64[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enum64AsStringArray, 47), + CompiledModelTestBase.Enum64[] (InternalEntityEntry entry) => entry.GetCurrentValue(enum64AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[47]); + enum64AsStringArray.SetPropertyIndexes( + index: 47, + originalValueIndex: 47, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum64AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v))))); enum64AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum64AsStringCollection = runtimeEntityType.AddProperty( @@ -1831,58 +2844,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64AsStringCollection(instance) == null); + enum64AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum64AsStringCollection(entity) = value); + enum64AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum64AsStringCollection(entity) = value); + enum64AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enum64AsStringCollection, 48), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enum64AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[48]); + enum64AsStringCollection.SetPropertyIndexes( + index: 48, + originalValueIndex: 48, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum64AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum64>(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum64>(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum64>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum64>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum64>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum64>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.Enum64 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum64 (string v) => StringEnumConverter.ConvertToEnum(v))))); enum64AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum64Collection = runtimeEntityType.AddProperty( @@ -1890,55 +2924,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum64Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum64Collection(instance) == null); + enum64Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum64Collection(entity) = value); + enum64Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum64Collection(entity) = value); + enum64Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum64Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enum64Collection, 49), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enum64Collection), + object (ValueBuffer valueBuffer) => valueBuffer[49]); + enum64Collection.SetPropertyIndexes( + index: 49, + originalValueIndex: 49, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum64Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum64>(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum64>(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum64>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum64>( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum64>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum64>( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))))), elementMapping: MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))); + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))); enum64Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum8 = runtimeEntityType.AddProperty( @@ -1946,27 +3001,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum8), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8.SetGetter( + CompiledModelTestBase.Enum8 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum8(entity))), ((object)(CompiledModelTestBase.Enum8.Default))), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum8(instance))), ((object)(CompiledModelTestBase.Enum8.Default)))); + enum8.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8 value) => ManyTypesUnsafeAccessors.Enum8(entity) = value); + enum8.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8 value) => ManyTypesUnsafeAccessors.Enum8(entity) = value); + enum8.SetAccessors( + CompiledModelTestBase.Enum8 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8 (InternalEntityEntry entry) => entry.ReadOriginalValue(enum8, 50), + CompiledModelTestBase.Enum8 (InternalEntityEntry entry) => entry.GetCurrentValue(enum8), + object (ValueBuffer valueBuffer) => valueBuffer[50]); + enum8.SetPropertyIndexes( + index: 50, + originalValueIndex: 50, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum8.TypeMapping = MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value))); + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))))); enum8.SetSentinelFromProviderValue((sbyte)0); enum8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -1975,55 +3051,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum8[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8Array.SetGetter( + CompiledModelTestBase.Enum8[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8Array(entity) == null, + CompiledModelTestBase.Enum8[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8Array(instance) == null); + enum8Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8[] value) => ManyTypesUnsafeAccessors.Enum8Array(entity) = value); + enum8Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8[] value) => ManyTypesUnsafeAccessors.Enum8Array(entity) = value); + enum8Array.SetAccessors( + CompiledModelTestBase.Enum8[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enum8Array, 51), + CompiledModelTestBase.Enum8[] (InternalEntityEntry entry) => entry.GetCurrentValue(enum8Array), + object (ValueBuffer valueBuffer) => valueBuffer[51]); + enum8Array.SetPropertyIndexes( + index: 51, + originalValueIndex: 51, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum8Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))))), elementMapping: MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))); + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))); enum8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum8AsString = runtimeEntityType.AddProperty( @@ -2032,30 +3129,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), providerPropertyType: typeof(string)); + enum8AsString.SetGetter( + CompiledModelTestBase.Enum8 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum8AsString(entity))), ((object)(CompiledModelTestBase.Enum8.Default))), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.Enum8AsString(instance))), ((object)(CompiledModelTestBase.Enum8.Default)))); + enum8AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8 value) => ManyTypesUnsafeAccessors.Enum8AsString(entity) = value); + enum8AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8 value) => ManyTypesUnsafeAccessors.Enum8AsString(entity) = value); + enum8AsString.SetAccessors( + CompiledModelTestBase.Enum8 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8 (InternalEntityEntry entry) => entry.ReadOriginalValue(enum8AsString, 52), + CompiledModelTestBase.Enum8 (InternalEntityEntry entry) => entry.GetCurrentValue(enum8AsString), + object (ValueBuffer valueBuffer) => valueBuffer[52]); + enum8AsString.SetPropertyIndexes( + index: 52, + originalValueIndex: 52, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum8AsString.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))); + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v)))); enum8AsString.SetSentinelFromProviderValue("Default"); enum8AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -2064,58 +3182,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum8[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8AsStringArray.SetGetter( + CompiledModelTestBase.Enum8[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8AsStringArray(entity) == null, + CompiledModelTestBase.Enum8[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8AsStringArray(instance) == null); + enum8AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8[] value) => ManyTypesUnsafeAccessors.Enum8AsStringArray(entity) = value); + enum8AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8[] value) => ManyTypesUnsafeAccessors.Enum8AsStringArray(entity) = value); + enum8AsStringArray.SetAccessors( + CompiledModelTestBase.Enum8[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enum8AsStringArray, 53), + CompiledModelTestBase.Enum8[] (InternalEntityEntry entry) => entry.GetCurrentValue(enum8AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[53]); + enum8AsStringArray.SetPropertyIndexes( + index: 53, + originalValueIndex: 53, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum8AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v))))); enum8AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum8AsStringCollection = runtimeEntityType.AddProperty( @@ -2123,58 +3262,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8AsStringCollection(instance) == null); + enum8AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum8AsStringCollection(entity) = value); + enum8AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum8AsStringCollection(entity) = value); + enum8AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enum8AsStringCollection, 54), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enum8AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[54]); + enum8AsStringCollection.SetPropertyIndexes( + index: 54, + originalValueIndex: 54, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum8AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum8>(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum8>(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum8>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum8>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum8>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum8>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.Enum8 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum8 (string v) => StringEnumConverter.ConvertToEnum(v))))); enum8AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum8Collection = runtimeEntityType.AddProperty( @@ -2182,55 +3342,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Enum8Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Enum8Collection(instance) == null); + enum8Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum8Collection(entity) = value); + enum8Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.Enum8Collection(entity) = value); + enum8Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Enum8Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enum8Collection, 55), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enum8Collection), + object (ValueBuffer valueBuffer) => valueBuffer[55]); + enum8Collection.SetPropertyIndexes( + index: 55, + originalValueIndex: 55, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum8Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum8>(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.Enum8>(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum8>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum8>( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.Enum8>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.Enum8>( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))))), elementMapping: MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))); + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))); enum8Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumToNumberConverterProperty = runtimeEntityType.AddProperty( @@ -2239,27 +3420,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumToNumberConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new EnumToNumberConverter()); + enumToNumberConverterProperty.SetGetter( + CompiledModelTestBase.Enum32 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumToNumberConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumToNumberConverterProperty(entity))), ((object)(CompiledModelTestBase.Enum32.Default))), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumToNumberConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumToNumberConverterProperty(instance))), ((object)(CompiledModelTestBase.Enum32.Default)))); + enumToNumberConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32 value) => ManyTypesUnsafeAccessors.EnumToNumberConverterProperty(entity) = value); + enumToNumberConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32 value) => ManyTypesUnsafeAccessors.EnumToNumberConverterProperty(entity) = value); + enumToNumberConverterProperty.SetAccessors( + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumToNumberConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumToNumberConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumToNumberConverterProperty, 56), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => entry.GetCurrentValue(enumToNumberConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[56]); + enumToNumberConverterProperty.SetPropertyIndexes( + index: 56, + originalValueIndex: 56, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumToNumberConverterProperty.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))); enumToNumberConverterProperty.SetSentinelFromProviderValue(0); enumToNumberConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -2269,30 +3471,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new EnumToStringConverter()); + enumToStringConverterProperty.SetGetter( + CompiledModelTestBase.Enum32 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumToStringConverterProperty(entity))), ((object)(CompiledModelTestBase.Enum32.Default))), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumToStringConverterProperty(instance))), ((object)(CompiledModelTestBase.Enum32.Default)))); + enumToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32 value) => ManyTypesUnsafeAccessors.EnumToStringConverterProperty(entity) = value); + enumToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32 value) => ManyTypesUnsafeAccessors.EnumToStringConverterProperty(entity) = value); + enumToStringConverterProperty.SetAccessors( + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumToStringConverterProperty, 57), + CompiledModelTestBase.Enum32 (InternalEntityEntry entry) => entry.GetCurrentValue(enumToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[57]); + enumToStringConverterProperty.SetPropertyIndexes( + index: 57, + originalValueIndex: 57, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))); + string (CompiledModelTestBase.Enum32 v) => ((object)v).ToString(), + CompiledModelTestBase.Enum32 (string v) => StringEnumConverter.ConvertToEnum(v)))); enumToStringConverterProperty.SetSentinelFromProviderValue("Default"); enumToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -2301,27 +3524,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU16), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16.SetGetter( + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU16(entity))), ((object)(CompiledModelTestBase.EnumU16.Min))), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU16(instance))), ((object)(CompiledModelTestBase.EnumU16.Min)))); + enumU16.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16 value) => ManyTypesUnsafeAccessors.EnumU16(entity) = value); + enumU16.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16 value) => ManyTypesUnsafeAccessors.EnumU16(entity) = value); + enumU16.SetAccessors( + CompiledModelTestBase.EnumU16 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU16, 58), + CompiledModelTestBase.EnumU16 (InternalEntityEntry entry) => entry.GetCurrentValue(enumU16), + object (ValueBuffer valueBuffer) => valueBuffer[58]); + enumU16.SetPropertyIndexes( + index: 58, + originalValueIndex: 58, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU16.TypeMapping = MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value))); + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))))); enumU16.SetSentinelFromProviderValue((ushort)0); enumU16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -2330,55 +3574,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU16[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16Array.SetGetter( + CompiledModelTestBase.EnumU16[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16Array(entity) == null, + CompiledModelTestBase.EnumU16[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16Array(instance) == null); + enumU16Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16[] value) => ManyTypesUnsafeAccessors.EnumU16Array(entity) = value); + enumU16Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16[] value) => ManyTypesUnsafeAccessors.EnumU16Array(entity) = value); + enumU16Array.SetAccessors( + CompiledModelTestBase.EnumU16[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU16Array, 59), + CompiledModelTestBase.EnumU16[] (InternalEntityEntry entry) => entry.GetCurrentValue(enumU16Array), + object (ValueBuffer valueBuffer) => valueBuffer[59]); + enumU16Array.SetPropertyIndexes( + index: 59, + originalValueIndex: 59, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU16Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))))), elementMapping: MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))); + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))); enumU16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU16AsString = runtimeEntityType.AddProperty( @@ -2387,30 +3652,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), providerPropertyType: typeof(string)); + enumU16AsString.SetGetter( + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU16AsString(entity))), ((object)(CompiledModelTestBase.EnumU16.Min))), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU16AsString(instance))), ((object)(CompiledModelTestBase.EnumU16.Min)))); + enumU16AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16 value) => ManyTypesUnsafeAccessors.EnumU16AsString(entity) = value); + enumU16AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16 value) => ManyTypesUnsafeAccessors.EnumU16AsString(entity) = value); + enumU16AsString.SetAccessors( + CompiledModelTestBase.EnumU16 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU16AsString, 60), + CompiledModelTestBase.EnumU16 (InternalEntityEntry entry) => entry.GetCurrentValue(enumU16AsString), + object (ValueBuffer valueBuffer) => valueBuffer[60]); + enumU16AsString.SetPropertyIndexes( + index: 60, + originalValueIndex: 60, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU16AsString.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))); + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v)))); enumU16AsString.SetSentinelFromProviderValue("Min"); enumU16AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -2419,58 +3705,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU16[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16AsStringArray.SetGetter( + CompiledModelTestBase.EnumU16[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16AsStringArray(entity) == null, + CompiledModelTestBase.EnumU16[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16AsStringArray(instance) == null); + enumU16AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16[] value) => ManyTypesUnsafeAccessors.EnumU16AsStringArray(entity) = value); + enumU16AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16[] value) => ManyTypesUnsafeAccessors.EnumU16AsStringArray(entity) = value); + enumU16AsStringArray.SetAccessors( + CompiledModelTestBase.EnumU16[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU16AsStringArray, 61), + CompiledModelTestBase.EnumU16[] (InternalEntityEntry entry) => entry.GetCurrentValue(enumU16AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[61]); + enumU16AsStringArray.SetPropertyIndexes( + index: 61, + originalValueIndex: 61, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU16AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v))))); enumU16AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU16AsStringCollection = runtimeEntityType.AddProperty( @@ -2478,58 +3785,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16AsStringCollection(instance) == null); + enumU16AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU16AsStringCollection(entity) = value); + enumU16AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU16AsStringCollection(entity) = value); + enumU16AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enumU16AsStringCollection, 62), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enumU16AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[62]); + enumU16AsStringCollection.SetPropertyIndexes( + index: 62, + originalValueIndex: 62, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU16AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU16>(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU16>(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU16>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU16>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU16>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU16>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.EnumU16 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU16 (string v) => StringEnumConverter.ConvertToEnum(v))))); enumU16AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU16Collection = runtimeEntityType.AddProperty( @@ -2537,55 +3865,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU16Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU16Collection(instance) == null); + enumU16Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU16Collection(entity) = value); + enumU16Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU16Collection(entity) = value); + enumU16Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU16Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enumU16Collection, 63), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enumU16Collection), + object (ValueBuffer valueBuffer) => valueBuffer[63]); + enumU16Collection.SetPropertyIndexes( + index: 63, + originalValueIndex: 63, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU16Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU16>(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU16>(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU16>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU16>( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU16>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU16>( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))))), elementMapping: MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))); + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))); enumU16Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU32 = runtimeEntityType.AddProperty( @@ -2593,27 +3942,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU32), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32.SetGetter( + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU32(entity))), ((object)(CompiledModelTestBase.EnumU32.Min))), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU32(instance))), ((object)(CompiledModelTestBase.EnumU32.Min)))); + enumU32.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32 value) => ManyTypesUnsafeAccessors.EnumU32(entity) = value); + enumU32.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32 value) => ManyTypesUnsafeAccessors.EnumU32(entity) = value); + enumU32.SetAccessors( + CompiledModelTestBase.EnumU32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU32, 64), + CompiledModelTestBase.EnumU32 (InternalEntityEntry entry) => entry.GetCurrentValue(enumU32), + object (ValueBuffer valueBuffer) => valueBuffer[64]); + enumU32.SetPropertyIndexes( + index: 64, + originalValueIndex: 64, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU32.TypeMapping = MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value))); + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))))); enumU32.SetSentinelFromProviderValue(0u); enumU32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -2622,55 +3992,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU32[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32Array.SetGetter( + CompiledModelTestBase.EnumU32[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32Array(entity) == null, + CompiledModelTestBase.EnumU32[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32Array(instance) == null); + enumU32Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32[] value) => ManyTypesUnsafeAccessors.EnumU32Array(entity) = value); + enumU32Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32[] value) => ManyTypesUnsafeAccessors.EnumU32Array(entity) = value); + enumU32Array.SetAccessors( + CompiledModelTestBase.EnumU32[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU32Array, 65), + CompiledModelTestBase.EnumU32[] (InternalEntityEntry entry) => entry.GetCurrentValue(enumU32Array), + object (ValueBuffer valueBuffer) => valueBuffer[65]); + enumU32Array.SetPropertyIndexes( + index: 65, + originalValueIndex: 65, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU32Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))))), elementMapping: MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))); + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))); enumU32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU32AsString = runtimeEntityType.AddProperty( @@ -2679,30 +4070,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), providerPropertyType: typeof(string)); + enumU32AsString.SetGetter( + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU32AsString(entity))), ((object)(CompiledModelTestBase.EnumU32.Min))), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU32AsString(instance))), ((object)(CompiledModelTestBase.EnumU32.Min)))); + enumU32AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32 value) => ManyTypesUnsafeAccessors.EnumU32AsString(entity) = value); + enumU32AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32 value) => ManyTypesUnsafeAccessors.EnumU32AsString(entity) = value); + enumU32AsString.SetAccessors( + CompiledModelTestBase.EnumU32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU32AsString, 66), + CompiledModelTestBase.EnumU32 (InternalEntityEntry entry) => entry.GetCurrentValue(enumU32AsString), + object (ValueBuffer valueBuffer) => valueBuffer[66]); + enumU32AsString.SetPropertyIndexes( + index: 66, + originalValueIndex: 66, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU32AsString.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))); + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v)))); enumU32AsString.SetSentinelFromProviderValue("Min"); enumU32AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -2711,58 +4123,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU32[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32AsStringArray.SetGetter( + CompiledModelTestBase.EnumU32[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32AsStringArray(entity) == null, + CompiledModelTestBase.EnumU32[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32AsStringArray(instance) == null); + enumU32AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32[] value) => ManyTypesUnsafeAccessors.EnumU32AsStringArray(entity) = value); + enumU32AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32[] value) => ManyTypesUnsafeAccessors.EnumU32AsStringArray(entity) = value); + enumU32AsStringArray.SetAccessors( + CompiledModelTestBase.EnumU32[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU32AsStringArray, 67), + CompiledModelTestBase.EnumU32[] (InternalEntityEntry entry) => entry.GetCurrentValue(enumU32AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[67]); + enumU32AsStringArray.SetPropertyIndexes( + index: 67, + originalValueIndex: 67, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU32AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v))))); enumU32AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU32AsStringCollection = runtimeEntityType.AddProperty( @@ -2770,58 +4203,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32AsStringCollection(instance) == null); + enumU32AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU32AsStringCollection(entity) = value); + enumU32AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU32AsStringCollection(entity) = value); + enumU32AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enumU32AsStringCollection, 68), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enumU32AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[68]); + enumU32AsStringCollection.SetPropertyIndexes( + index: 68, + originalValueIndex: 68, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU32AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU32>(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU32>(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU32>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU32>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU32>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU32>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.EnumU32 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU32 (string v) => StringEnumConverter.ConvertToEnum(v))))); enumU32AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU32Collection = runtimeEntityType.AddProperty( @@ -2829,55 +4283,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU32Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU32Collection(instance) == null); + enumU32Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU32Collection(entity) = value); + enumU32Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU32Collection(entity) = value); + enumU32Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU32Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enumU32Collection, 69), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enumU32Collection), + object (ValueBuffer valueBuffer) => valueBuffer[69]); + enumU32Collection.SetPropertyIndexes( + index: 69, + originalValueIndex: 69, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU32Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU32>(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU32>(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU32>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU32>( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU32>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU32>( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))))), elementMapping: MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))); + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))); enumU32Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU64 = runtimeEntityType.AddProperty( @@ -2885,27 +4360,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU64), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64.SetGetter( + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU64(entity))), ((object)(CompiledModelTestBase.EnumU64.Min))), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU64(instance))), ((object)(CompiledModelTestBase.EnumU64.Min)))); + enumU64.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64 value) => ManyTypesUnsafeAccessors.EnumU64(entity) = value); + enumU64.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64 value) => ManyTypesUnsafeAccessors.EnumU64(entity) = value); + enumU64.SetAccessors( + CompiledModelTestBase.EnumU64 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU64, 70), + CompiledModelTestBase.EnumU64 (InternalEntityEntry entry) => entry.GetCurrentValue(enumU64), + object (ValueBuffer valueBuffer) => valueBuffer[70]); + enumU64.SetPropertyIndexes( + index: 70, + originalValueIndex: 70, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU64.TypeMapping = MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value))); + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))))); enumU64.SetSentinelFromProviderValue(0ul); enumU64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -2914,55 +4410,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU64[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64Array.SetGetter( + CompiledModelTestBase.EnumU64[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64Array(entity) == null, + CompiledModelTestBase.EnumU64[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64Array(instance) == null); + enumU64Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64[] value) => ManyTypesUnsafeAccessors.EnumU64Array(entity) = value); + enumU64Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64[] value) => ManyTypesUnsafeAccessors.EnumU64Array(entity) = value); + enumU64Array.SetAccessors( + CompiledModelTestBase.EnumU64[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU64Array, 71), + CompiledModelTestBase.EnumU64[] (InternalEntityEntry entry) => entry.GetCurrentValue(enumU64Array), + object (ValueBuffer valueBuffer) => valueBuffer[71]); + enumU64Array.SetPropertyIndexes( + index: 71, + originalValueIndex: 71, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU64Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))))), elementMapping: MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))); + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))); enumU64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU64AsString = runtimeEntityType.AddProperty( @@ -2971,30 +4488,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), providerPropertyType: typeof(string)); + enumU64AsString.SetGetter( + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU64AsString(entity))), ((object)(CompiledModelTestBase.EnumU64.Min))), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU64AsString(instance))), ((object)(CompiledModelTestBase.EnumU64.Min)))); + enumU64AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64 value) => ManyTypesUnsafeAccessors.EnumU64AsString(entity) = value); + enumU64AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64 value) => ManyTypesUnsafeAccessors.EnumU64AsString(entity) = value); + enumU64AsString.SetAccessors( + CompiledModelTestBase.EnumU64 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU64AsString, 72), + CompiledModelTestBase.EnumU64 (InternalEntityEntry entry) => entry.GetCurrentValue(enumU64AsString), + object (ValueBuffer valueBuffer) => valueBuffer[72]); + enumU64AsString.SetPropertyIndexes( + index: 72, + originalValueIndex: 72, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU64AsString.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))); + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v)))); enumU64AsString.SetSentinelFromProviderValue("Min"); enumU64AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -3003,58 +4541,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU64[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64AsStringArray.SetGetter( + CompiledModelTestBase.EnumU64[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64AsStringArray(entity) == null, + CompiledModelTestBase.EnumU64[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64AsStringArray(instance) == null); + enumU64AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64[] value) => ManyTypesUnsafeAccessors.EnumU64AsStringArray(entity) = value); + enumU64AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64[] value) => ManyTypesUnsafeAccessors.EnumU64AsStringArray(entity) = value); + enumU64AsStringArray.SetAccessors( + CompiledModelTestBase.EnumU64[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU64AsStringArray, 73), + CompiledModelTestBase.EnumU64[] (InternalEntityEntry entry) => entry.GetCurrentValue(enumU64AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[73]); + enumU64AsStringArray.SetPropertyIndexes( + index: 73, + originalValueIndex: 73, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU64AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v))))); enumU64AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU64AsStringCollection = runtimeEntityType.AddProperty( @@ -3062,58 +4621,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64AsStringCollection(instance) == null); + enumU64AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU64AsStringCollection(entity) = value); + enumU64AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU64AsStringCollection(entity) = value); + enumU64AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enumU64AsStringCollection, 74), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enumU64AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[74]); + enumU64AsStringCollection.SetPropertyIndexes( + index: 74, + originalValueIndex: 74, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU64AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU64>(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU64>(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU64>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU64>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU64>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU64>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.EnumU64 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU64 (string v) => StringEnumConverter.ConvertToEnum(v))))); enumU64AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU64Collection = runtimeEntityType.AddProperty( @@ -3121,55 +4701,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU64Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU64Collection(instance) == null); + enumU64Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU64Collection(entity) = value); + enumU64Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU64Collection(entity) = value); + enumU64Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU64Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enumU64Collection, 75), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enumU64Collection), + object (ValueBuffer valueBuffer) => valueBuffer[75]); + enumU64Collection.SetPropertyIndexes( + index: 75, + originalValueIndex: 75, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU64Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU64>(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU64>(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU64>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU64>( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU64>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU64>( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))))), elementMapping: MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))); + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))); enumU64Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU8 = runtimeEntityType.AddProperty( @@ -3177,27 +4778,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU8), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8.SetGetter( + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU8(entity))), ((object)(CompiledModelTestBase.EnumU8.Min))), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU8(instance))), ((object)(CompiledModelTestBase.EnumU8.Min)))); + enumU8.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8 value) => ManyTypesUnsafeAccessors.EnumU8(entity) = value); + enumU8.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8 value) => ManyTypesUnsafeAccessors.EnumU8(entity) = value); + enumU8.SetAccessors( + CompiledModelTestBase.EnumU8 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU8, 76), + CompiledModelTestBase.EnumU8 (InternalEntityEntry entry) => entry.GetCurrentValue(enumU8), + object (ValueBuffer valueBuffer) => valueBuffer[76]); + enumU8.SetPropertyIndexes( + index: 76, + originalValueIndex: 76, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU8.TypeMapping = MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value))); + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))))); enumU8.SetSentinelFromProviderValue((byte)0); enumU8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -3206,55 +4828,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU8[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8Array.SetGetter( + CompiledModelTestBase.EnumU8[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8Array(entity) == null, + CompiledModelTestBase.EnumU8[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8Array(instance) == null); + enumU8Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8[] value) => ManyTypesUnsafeAccessors.EnumU8Array(entity) = value); + enumU8Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8[] value) => ManyTypesUnsafeAccessors.EnumU8Array(entity) = value); + enumU8Array.SetAccessors( + CompiledModelTestBase.EnumU8[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU8Array, 77), + CompiledModelTestBase.EnumU8[] (InternalEntityEntry entry) => entry.GetCurrentValue(enumU8Array), + object (ValueBuffer valueBuffer) => valueBuffer[77]); + enumU8Array.SetPropertyIndexes( + index: 77, + originalValueIndex: 77, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU8Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))))), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))); + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))); enumU8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU8AsString = runtimeEntityType.AddProperty( @@ -3263,30 +4906,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), providerPropertyType: typeof(string)); + enumU8AsString.SetGetter( + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU8AsString(entity))), ((object)(CompiledModelTestBase.EnumU8.Min))), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => object.Equals(((object)(ManyTypesUnsafeAccessors.EnumU8AsString(instance))), ((object)(CompiledModelTestBase.EnumU8.Min)))); + enumU8AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8 value) => ManyTypesUnsafeAccessors.EnumU8AsString(entity) = value); + enumU8AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8 value) => ManyTypesUnsafeAccessors.EnumU8AsString(entity) = value); + enumU8AsString.SetAccessors( + CompiledModelTestBase.EnumU8 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8 (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8 (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU8AsString, 78), + CompiledModelTestBase.EnumU8 (InternalEntityEntry entry) => entry.GetCurrentValue(enumU8AsString), + object (ValueBuffer valueBuffer) => valueBuffer[78]); + enumU8AsString.SetPropertyIndexes( + index: 78, + originalValueIndex: 78, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU8AsString.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))); + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v)))); enumU8AsString.SetSentinelFromProviderValue("Min"); enumU8AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -3295,58 +4959,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU8[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8AsStringArray.SetGetter( + CompiledModelTestBase.EnumU8[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8AsStringArray(entity) == null, + CompiledModelTestBase.EnumU8[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8AsStringArray(instance) == null); + enumU8AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8[] value) => ManyTypesUnsafeAccessors.EnumU8AsStringArray(entity) = value); + enumU8AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8[] value) => ManyTypesUnsafeAccessors.EnumU8AsStringArray(entity) = value); + enumU8AsStringArray.SetAccessors( + CompiledModelTestBase.EnumU8[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8[] (InternalEntityEntry entry) => entry.ReadOriginalValue(enumU8AsStringArray, 79), + CompiledModelTestBase.EnumU8[] (InternalEntityEntry entry) => entry.GetCurrentValue(enumU8AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[79]); + enumU8AsStringArray.SetPropertyIndexes( + index: 79, + originalValueIndex: 79, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU8AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v))))); enumU8AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU8AsStringCollection = runtimeEntityType.AddProperty( @@ -3354,58 +5039,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8AsStringCollection(instance) == null); + enumU8AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU8AsStringCollection(entity) = value); + enumU8AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU8AsStringCollection(entity) = value); + enumU8AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enumU8AsStringCollection, 80), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enumU8AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[80]); + enumU8AsStringCollection.SetPropertyIndexes( + index: 80, + originalValueIndex: 80, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU8AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU8>(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU8>(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU8>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU8>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))), + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU8>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU8>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)))), + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v)), + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 v) => v.ToString(), - (string v) => StringEnumConverter.ConvertToEnum(v))))); + string (CompiledModelTestBase.EnumU8 v) => ((object)v).ToString(), + CompiledModelTestBase.EnumU8 (string v) => StringEnumConverter.ConvertToEnum(v))))); enumU8AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enumU8Collection = runtimeEntityType.AddProperty( @@ -3413,55 +5119,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.EnumU8Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.EnumU8Collection(instance) == null); + enumU8Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU8Collection(entity) = value); + enumU8Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.EnumU8Collection(entity) = value); + enumU8Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.EnumU8Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(enumU8Collection, 81), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(enumU8Collection), + object (ValueBuffer valueBuffer) => valueBuffer[81]); + enumU8Collection.SetPropertyIndexes( + index: 81, + originalValueIndex: 81, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enumU8Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU8>(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v)), + keyComparer: new ListOfValueTypesComparer, CompiledModelTestBase.EnumU8>(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU8>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU8>( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, CompiledModelTestBase.EnumU8>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, CompiledModelTestBase.EnumU8>( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))))), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))); + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))); enumU8Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var @float = runtimeEntityType.AddProperty( @@ -3470,19 +5197,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Float", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: 0f); + @float.SetGetter( + float (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Float(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Float(entity).Equals(0F), + float (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Float(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Float(instance).Equals(0F)); + @float.SetSetter( + (CompiledModelTestBase.ManyTypes entity, float value) => ManyTypesUnsafeAccessors.Float(entity) = value); + @float.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, float value) => ManyTypesUnsafeAccessors.Float(entity) = value); + @float.SetAccessors( + float (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Float(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + float (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Float(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + float (InternalEntityEntry entry) => entry.ReadOriginalValue(@float, 82), + float (InternalEntityEntry entry) => entry.GetCurrentValue(@float), + object (ValueBuffer valueBuffer) => valueBuffer[82]); + @float.SetPropertyIndexes( + index: 82, + originalValueIndex: 82, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); @float.TypeMapping = MySqlFloatTypeMapping.Default.Clone( comparer: new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v), + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v), keyComparer: new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v), + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v), providerValueComparer: new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v)); + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v)); @float.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var floatArray = runtimeEntityType.AddProperty( @@ -3490,39 +5238,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(float[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("FloatArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + floatArray.SetGetter( + float[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.FloatArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.FloatArray(entity) == null, + float[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.FloatArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.FloatArray(instance) == null); + floatArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, float[] value) => ManyTypesUnsafeAccessors.FloatArray(entity) = value); + floatArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, float[] value) => ManyTypesUnsafeAccessors.FloatArray(entity) = value); + floatArray.SetAccessors( + float[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.FloatArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + float[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.FloatArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + float[] (InternalEntityEntry entry) => entry.ReadOriginalValue(floatArray, 83), + float[] (InternalEntityEntry entry) => entry.GetCurrentValue(floatArray), + object (ValueBuffer valueBuffer) => valueBuffer[83]); + floatArray.SetPropertyIndexes( + index: 83, + originalValueIndex: 83, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); floatArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonFloatReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonFloatReaderWriter.Instance), elementMapping: MySqlFloatTypeMapping.Default.Clone( comparer: new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v), + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v), keyComparer: new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v), + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v), providerValueComparer: new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v))); + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v))); floatArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var guid = runtimeEntityType.AddProperty( @@ -3531,19 +5300,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Guid", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + guid.SetGetter( + Guid (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Guid(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Guid(entity) == new Guid("00000000-0000-0000-0000-000000000000"), + Guid (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Guid(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Guid(instance) == new Guid("00000000-0000-0000-0000-000000000000")); + guid.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Guid value) => ManyTypesUnsafeAccessors.Guid(entity) = value); + guid.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Guid value) => ManyTypesUnsafeAccessors.Guid(entity) = value); + guid.SetAccessors( + Guid (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Guid(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Guid(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid (InternalEntityEntry entry) => entry.ReadOriginalValue(guid, 84), + Guid (InternalEntityEntry entry) => entry.GetCurrentValue(guid), + object (ValueBuffer valueBuffer) => valueBuffer[84]); + guid.SetPropertyIndexes( + index: 84, + originalValueIndex: 84, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); guid.TypeMapping = MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v)); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)); guid.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var guidArray = runtimeEntityType.AddProperty( @@ -3551,39 +5341,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(Guid[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("GuidArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + guidArray.SetGetter( + Guid[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.GuidArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.GuidArray(entity) == null, + Guid[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.GuidArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.GuidArray(instance) == null); + guidArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Guid[] value) => ManyTypesUnsafeAccessors.GuidArray(entity) = value); + guidArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Guid[] value) => ManyTypesUnsafeAccessors.GuidArray(entity) = value); + guidArray.SetAccessors( + Guid[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.GuidArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.GuidArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid[] (InternalEntityEntry entry) => entry.ReadOriginalValue(guidArray, 85), + Guid[] (InternalEntityEntry entry) => entry.GetCurrentValue(guidArray), + object (ValueBuffer valueBuffer) => valueBuffer[85]); + guidArray.SetPropertyIndexes( + index: 85, + originalValueIndex: 85, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); guidArray.TypeMapping = MySqlStringTypeMapping.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), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonGuidReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonGuidReaderWriter.Instance), elementMapping: MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v))); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v))); guidArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var guidToBytesConverterProperty = runtimeEntityType.AddProperty( @@ -3592,31 +5403,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("GuidToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new GuidToBytesConverter()); + guidToBytesConverterProperty.SetGetter( + Guid (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.GuidToBytesConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.GuidToBytesConverterProperty(entity) == new Guid("00000000-0000-0000-0000-000000000000"), + Guid (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.GuidToBytesConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.GuidToBytesConverterProperty(instance) == new Guid("00000000-0000-0000-0000-000000000000")); + guidToBytesConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Guid value) => ManyTypesUnsafeAccessors.GuidToBytesConverterProperty(entity) = value); + guidToBytesConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Guid value) => ManyTypesUnsafeAccessors.GuidToBytesConverterProperty(entity) = value); + guidToBytesConverterProperty.SetAccessors( + Guid (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.GuidToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.GuidToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid (InternalEntityEntry entry) => entry.ReadOriginalValue(guidToBytesConverterProperty, 86), + Guid (InternalEntityEntry entry) => entry.GetCurrentValue(guidToBytesConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[86]); + guidToBytesConverterProperty.SetPropertyIndexes( + index: 86, + originalValueIndex: 86, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); guidToBytesConverterProperty.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varbinary(16)", size: 16), converter: new ValueConverter( - (Guid v) => v.ToByteArray(), - (Byte[] v) => new Guid(v)), + byte[] (Guid v) => v.ToByteArray(), + Guid (byte[] v) => new Guid(v)), storeTypePostfix: StoreTypePostfix.Size, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteArrayReaderWriter.Instance, new ValueConverter( - (Guid v) => v.ToByteArray(), - (Byte[] v) => new Guid(v)))); + byte[] (Guid v) => v.ToByteArray(), + Guid (byte[] v) => new Guid(v)))); guidToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); guidToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -3626,30 +5458,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("GuidToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new GuidToStringConverter()); + guidToStringConverterProperty.SetGetter( + Guid (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.GuidToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.GuidToStringConverterProperty(entity) == new Guid("00000000-0000-0000-0000-000000000000"), + Guid (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.GuidToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.GuidToStringConverterProperty(instance) == new Guid("00000000-0000-0000-0000-000000000000")); + guidToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Guid value) => ManyTypesUnsafeAccessors.GuidToStringConverterProperty(entity) = value); + guidToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Guid value) => ManyTypesUnsafeAccessors.GuidToStringConverterProperty(entity) = value); + guidToStringConverterProperty.SetAccessors( + Guid (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.GuidToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.GuidToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid (InternalEntityEntry entry) => entry.ReadOriginalValue(guidToStringConverterProperty, 87), + Guid (InternalEntityEntry entry) => entry.GetCurrentValue(guidToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[87]); + guidToStringConverterProperty.SetPropertyIndexes( + index: 87, + originalValueIndex: 87, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); guidToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(36)", size: 36), converter: new ValueConverter( - (Guid v) => v.ToString("D"), - (string v) => new Guid(v)), + string (Guid v) => v.ToString("D"), + Guid (string v) => new Guid(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Guid v) => v.ToString("D"), - (string v) => new Guid(v)))); + string (Guid v) => v.ToString("D"), + Guid (string v) => new Guid(v)))); guidToStringConverterProperty.SetSentinelFromProviderValue("00000000-0000-0000-0000-000000000000"); guidToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -3658,30 +5511,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(IPAddress), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IPAddress", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + iPAddress.SetGetter( + IPAddress (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IPAddress(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IPAddress(entity) == null, + IPAddress (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IPAddress(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IPAddress(instance) == null); + iPAddress.SetSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress value) => ManyTypesUnsafeAccessors.IPAddress(entity) = value); + iPAddress.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress value) => ManyTypesUnsafeAccessors.IPAddress(entity) = value); + iPAddress.SetAccessors( + IPAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IPAddress(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IPAddress(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress (InternalEntityEntry entry) => entry.ReadOriginalValue(iPAddress, 88), + IPAddress (InternalEntityEntry entry) => entry.GetCurrentValue(iPAddress), + object (ValueBuffer valueBuffer) => valueBuffer[88]); + iPAddress.SetPropertyIndexes( + index: 88, + originalValueIndex: 88, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); iPAddress.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))); iPAddress.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var iPAddressArray = runtimeEntityType.AddProperty( @@ -3689,58 +5563,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(IPAddress[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IPAddressArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + iPAddressArray.SetGetter( + IPAddress[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IPAddressArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IPAddressArray(entity) == null, + IPAddress[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IPAddressArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IPAddressArray(instance) == null); + iPAddressArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress[] value) => ManyTypesUnsafeAccessors.IPAddressArray(entity) = value); + iPAddressArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress[] value) => ManyTypesUnsafeAccessors.IPAddressArray(entity) = value); + iPAddressArray.SetAccessors( + IPAddress[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IPAddressArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IPAddressArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => entry.ReadOriginalValue(iPAddressArray, 89), + IPAddress[] (InternalEntityEntry entry) => entry.GetCurrentValue(iPAddressArray), + object (ValueBuffer valueBuffer) => valueBuffer[89]); + iPAddressArray.SetPropertyIndexes( + index: 89, + originalValueIndex: 89, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); iPAddressArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); iPAddressArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var iPAddressToBytesConverterProperty = runtimeEntityType.AddProperty( @@ -3749,31 +5644,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IPAddressToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new IPAddressToBytesConverter()); + iPAddressToBytesConverterProperty.SetGetter( + IPAddress (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IPAddressToBytesConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IPAddressToBytesConverterProperty(entity) == null, + IPAddress (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IPAddressToBytesConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IPAddressToBytesConverterProperty(instance) == null); + iPAddressToBytesConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress value) => ManyTypesUnsafeAccessors.IPAddressToBytesConverterProperty(entity) = value); + iPAddressToBytesConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress value) => ManyTypesUnsafeAccessors.IPAddressToBytesConverterProperty(entity) = value); + iPAddressToBytesConverterProperty.SetAccessors( + IPAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IPAddressToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IPAddressToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress (InternalEntityEntry entry) => entry.ReadOriginalValue(iPAddressToBytesConverterProperty, 90), + IPAddress (InternalEntityEntry entry) => entry.GetCurrentValue(iPAddressToBytesConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[90]); + iPAddressToBytesConverterProperty.SetPropertyIndexes( + index: 90, + originalValueIndex: 90, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); iPAddressToBytesConverterProperty.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varbinary(16)", size: 16), converter: new ValueConverter( - (IPAddress v) => v.GetAddressBytes(), - (Byte[] v) => new IPAddress(v)), + byte[] (IPAddress v) => v.GetAddressBytes(), + IPAddress (byte[] v) => new IPAddress(v)), storeTypePostfix: StoreTypePostfix.Size, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteArrayReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.GetAddressBytes(), - (Byte[] v) => new IPAddress(v)))); + byte[] (IPAddress v) => v.GetAddressBytes(), + IPAddress (byte[] v) => new IPAddress(v)))); iPAddressToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var iPAddressToStringConverterProperty = runtimeEntityType.AddProperty( @@ -3782,30 +5698,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IPAddressToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new IPAddressToStringConverter()); + iPAddressToStringConverterProperty.SetGetter( + IPAddress (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IPAddressToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IPAddressToStringConverterProperty(entity) == null, + IPAddress (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IPAddressToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IPAddressToStringConverterProperty(instance) == null); + iPAddressToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress value) => ManyTypesUnsafeAccessors.IPAddressToStringConverterProperty(entity) = value); + iPAddressToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress value) => ManyTypesUnsafeAccessors.IPAddressToStringConverterProperty(entity) = value); + iPAddressToStringConverterProperty.SetAccessors( + IPAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IPAddressToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IPAddressToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress (InternalEntityEntry entry) => entry.ReadOriginalValue(iPAddressToStringConverterProperty, 91), + IPAddress (InternalEntityEntry entry) => entry.GetCurrentValue(iPAddressToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[91]); + iPAddressToStringConverterProperty.SetPropertyIndexes( + index: 91, + originalValueIndex: 91, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); iPAddressToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))); iPAddressToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var int16 = runtimeEntityType.AddProperty( @@ -3814,19 +5751,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: (short)0); + int16.SetGetter( + short (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int16(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int16(entity) == 0, + short (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int16(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int16(instance) == 0); + int16.SetSetter( + (CompiledModelTestBase.ManyTypes entity, short value) => ManyTypesUnsafeAccessors.Int16(entity) = value); + int16.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, short value) => ManyTypesUnsafeAccessors.Int16(entity) = value); + int16.SetAccessors( + short (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + short (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + short (InternalEntityEntry entry) => entry.ReadOriginalValue(int16, 92), + short (InternalEntityEntry entry) => entry.GetCurrentValue(int16), + object (ValueBuffer valueBuffer) => valueBuffer[92]); + int16.SetPropertyIndexes( + index: 92, + originalValueIndex: 92, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); int16.TypeMapping = MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), keyComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v)); + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)); int16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var int16Array = runtimeEntityType.AddProperty( @@ -3834,39 +5792,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(short[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + int16Array.SetGetter( + short[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int16Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int16Array(entity) == null, + short[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int16Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int16Array(instance) == null); + int16Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, short[] value) => ManyTypesUnsafeAccessors.Int16Array(entity) = value); + int16Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, short[] value) => ManyTypesUnsafeAccessors.Int16Array(entity) = value); + int16Array.SetAccessors( + short[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + short[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + short[] (InternalEntityEntry entry) => entry.ReadOriginalValue(int16Array, 93), + short[] (InternalEntityEntry entry) => entry.GetCurrentValue(int16Array), + object (ValueBuffer valueBuffer) => valueBuffer[93]); + int16Array.SetPropertyIndexes( + index: 93, + originalValueIndex: 93, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); int16Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonInt16ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonInt16ReaderWriter.Instance), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), keyComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v))); + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v))); int16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var int32 = runtimeEntityType.AddProperty( @@ -3875,19 +5854,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: 0); + int32.SetGetter( + int (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int32(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int32(entity) == 0, + int (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int32(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int32(instance) == 0); + int32.SetSetter( + (CompiledModelTestBase.ManyTypes entity, int value) => ManyTypesUnsafeAccessors.Int32(entity) = value); + int32.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, int value) => ManyTypesUnsafeAccessors.Int32(entity) = value); + int32.SetAccessors( + int (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(int32, 94), + int (InternalEntityEntry entry) => entry.GetCurrentValue(int32), + object (ValueBuffer valueBuffer) => valueBuffer[94]); + int32.SetPropertyIndexes( + index: 94, + originalValueIndex: 94, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); int32.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); int32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var int32Array = runtimeEntityType.AddProperty( @@ -3895,39 +5895,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(int[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + int32Array.SetGetter( + int[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int32Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int32Array(entity) == null, + int[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int32Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int32Array(instance) == null); + int32Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, int[] value) => ManyTypesUnsafeAccessors.Int32Array(entity) = value); + int32Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, int[] value) => ManyTypesUnsafeAccessors.Int32Array(entity) = value); + int32Array.SetAccessors( + int[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int[] (InternalEntityEntry entry) => entry.ReadOriginalValue(int32Array, 95), + int[] (InternalEntityEntry entry) => entry.GetCurrentValue(int32Array), + object (ValueBuffer valueBuffer) => valueBuffer[95]); + int32Array.SetPropertyIndexes( + index: 95, + originalValueIndex: 95, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); int32Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonInt32ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonInt32ReaderWriter.Instance), elementMapping: MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v))); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v))); int32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var int64 = runtimeEntityType.AddProperty( @@ -3936,19 +5957,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: 0L); + int64.SetGetter( + long (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int64(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int64(entity) == 0L, + long (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int64(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int64(instance) == 0L); + int64.SetSetter( + (CompiledModelTestBase.ManyTypes entity, long value) => ManyTypesUnsafeAccessors.Int64(entity) = value); + int64.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, long value) => ManyTypesUnsafeAccessors.Int64(entity) = value); + int64.SetAccessors( + long (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + long (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + long (InternalEntityEntry entry) => entry.ReadOriginalValue(int64, 96), + long (InternalEntityEntry entry) => entry.GetCurrentValue(int64), + object (ValueBuffer valueBuffer) => valueBuffer[96]); + int64.SetPropertyIndexes( + index: 96, + originalValueIndex: 96, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); int64.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), keyComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v)); + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); int64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var int64Array = runtimeEntityType.AddProperty( @@ -3956,39 +5998,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(long[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + int64Array.SetGetter( + long[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int64Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int64Array(entity) == null, + long[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int64Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int64Array(instance) == null); + int64Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, long[] value) => ManyTypesUnsafeAccessors.Int64Array(entity) = value); + int64Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, long[] value) => ManyTypesUnsafeAccessors.Int64Array(entity) = value); + int64Array.SetAccessors( + long[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + long[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + long[] (InternalEntityEntry entry) => entry.ReadOriginalValue(int64Array, 97), + long[] (InternalEntityEntry entry) => entry.GetCurrentValue(int64Array), + object (ValueBuffer valueBuffer) => valueBuffer[97]); + int64Array.SetPropertyIndexes( + index: 97, + originalValueIndex: 97, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); int64Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonInt64ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonInt64ReaderWriter.Instance), elementMapping: MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), keyComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v))); + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v))); int64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var int8 = runtimeEntityType.AddProperty( @@ -3997,19 +6060,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: (sbyte)0); + int8.SetGetter( + sbyte (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int8(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int8(entity) == 0, + sbyte (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int8(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int8(instance) == 0); + int8.SetSetter( + (CompiledModelTestBase.ManyTypes entity, sbyte value) => ManyTypesUnsafeAccessors.Int8(entity) = value); + int8.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, sbyte value) => ManyTypesUnsafeAccessors.Int8(entity) = value); + int8.SetAccessors( + sbyte (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + sbyte (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + sbyte (InternalEntityEntry entry) => entry.ReadOriginalValue(int8, 98), + sbyte (InternalEntityEntry entry) => entry.GetCurrentValue(int8), + object (ValueBuffer valueBuffer) => valueBuffer[98]); + int8.SetPropertyIndexes( + index: 98, + originalValueIndex: 98, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); int8.TypeMapping = MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), keyComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v)); + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v)); int8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var int8Array = runtimeEntityType.AddProperty( @@ -4017,39 +6101,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(sbyte[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + int8Array.SetGetter( + sbyte[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int8Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Int8Array(entity) == null, + sbyte[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int8Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Int8Array(instance) == null); + int8Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, sbyte[] value) => ManyTypesUnsafeAccessors.Int8Array(entity) = value); + int8Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, sbyte[] value) => ManyTypesUnsafeAccessors.Int8Array(entity) = value); + int8Array.SetAccessors( + sbyte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + sbyte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Int8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + sbyte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(int8Array, 99), + sbyte[] (InternalEntityEntry entry) => entry.GetCurrentValue(int8Array), + object (ValueBuffer valueBuffer) => valueBuffer[99]); + int8Array.SetPropertyIndexes( + index: 99, + originalValueIndex: 99, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); int8Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonSByteReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonSByteReaderWriter.Instance), elementMapping: MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), keyComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v))); + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v))); int8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var intNumberToBytesConverterProperty = runtimeEntityType.AddProperty( @@ -4058,31 +6163,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IntNumberToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new NumberToBytesConverter()); + intNumberToBytesConverterProperty.SetGetter( + int (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IntNumberToBytesConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IntNumberToBytesConverterProperty(entity) == 0, + int (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IntNumberToBytesConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IntNumberToBytesConverterProperty(instance) == 0); + intNumberToBytesConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, int value) => ManyTypesUnsafeAccessors.IntNumberToBytesConverterProperty(entity) = value); + intNumberToBytesConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, int value) => ManyTypesUnsafeAccessors.IntNumberToBytesConverterProperty(entity) = value); + intNumberToBytesConverterProperty.SetAccessors( + int (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IntNumberToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IntNumberToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(intNumberToBytesConverterProperty, 100), + int (InternalEntityEntry entry) => entry.GetCurrentValue(intNumberToBytesConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[100]); + intNumberToBytesConverterProperty.SetPropertyIndexes( + index: 100, + originalValueIndex: 100, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); intNumberToBytesConverterProperty.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varbinary(4)", size: 4), converter: new ValueConverter( - (int v) => NumberToBytesConverter.ReverseInt(BitConverter.GetBytes(v)), - (Byte[] v) => v == null ? 0 : BitConverter.ToInt32(NumberToBytesConverter.ReverseInt(v.Length == 0 ? new byte[4] : v), 0)), + byte[] (int v) => NumberToBytesConverter.ReverseInt(BitConverter.GetBytes(v)), + int (byte[] v) => (v == null ? 0 : BitConverter.ToInt32(NumberToBytesConverter.ReverseInt((v.Length == 0 ? new byte[4] : v)), 0))), storeTypePostfix: StoreTypePostfix.Size, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteArrayReaderWriter.Instance, new ValueConverter( - (int v) => NumberToBytesConverter.ReverseInt(BitConverter.GetBytes(v)), - (Byte[] v) => v == null ? 0 : BitConverter.ToInt32(NumberToBytesConverter.ReverseInt(v.Length == 0 ? new byte[4] : v), 0)))); + byte[] (int v) => NumberToBytesConverter.ReverseInt(BitConverter.GetBytes(v)), + int (byte[] v) => (v == null ? 0 : BitConverter.ToInt32(NumberToBytesConverter.ReverseInt((v.Length == 0 ? new byte[4] : v)), 0))))); intNumberToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0 }); intNumberToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -4092,30 +6218,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IntNumberToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new NumberToStringConverter()); + intNumberToStringConverterProperty.SetGetter( + int (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IntNumberToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.IntNumberToStringConverterProperty(entity) == 0, + int (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IntNumberToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.IntNumberToStringConverterProperty(instance) == 0); + intNumberToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, int value) => ManyTypesUnsafeAccessors.IntNumberToStringConverterProperty(entity) = value); + intNumberToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, int value) => ManyTypesUnsafeAccessors.IntNumberToStringConverterProperty(entity) = value); + intNumberToStringConverterProperty.SetAccessors( + int (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IntNumberToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.IntNumberToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(intNumberToStringConverterProperty, 101), + int (InternalEntityEntry entry) => entry.GetCurrentValue(intNumberToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[101]); + intNumberToStringConverterProperty.SetPropertyIndexes( + index: 101, + originalValueIndex: 101, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); intNumberToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(64)", size: 64), converter: new ValueConverter( - (int v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => int.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)), + string (int v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + int (string v) => int.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (int v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => int.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)))); + string (int v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + int (string v) => int.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture)))); intNumberToStringConverterProperty.SetSentinelFromProviderValue("0"); intNumberToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -4126,31 +6273,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true, valueConverter: new CompiledModelTestBase.NullIntToNullStringConverter()); + nullIntToNullStringConverterProperty.SetGetter( + int? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullIntToNullStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullIntToNullStringConverterProperty(entity).HasValue), + int? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullIntToNullStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullIntToNullStringConverterProperty(instance).HasValue)); + nullIntToNullStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, int? value) => ManyTypesUnsafeAccessors.NullIntToNullStringConverterProperty(entity) = value); + nullIntToNullStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, int? value) => ManyTypesUnsafeAccessors.NullIntToNullStringConverterProperty(entity) = value); + nullIntToNullStringConverterProperty.SetAccessors( + int? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullIntToNullStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullIntToNullStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullIntToNullStringConverterProperty, 102), + int? (InternalEntityEntry entry) => entry.GetCurrentValue(nullIntToNullStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[102]); + nullIntToNullStringConverterProperty.SetPropertyIndexes( + index: 102, + originalValueIndex: 102, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullIntToNullStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1 == v2, - (Nullable v) => (int)v, - (Nullable v) => v), + bool (int? v1, int? v2) => v1 == v2, + int (int? v) => ((int)(v)), + int? (int? v) => v), keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1 == v2, - (Nullable v) => (int)v, - (Nullable v) => v), + bool (int? v1, int? v2) => v1 == v2, + int (int? v) => ((int)(v)), + int? (int? v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (Nullable v) => v == null ? null : v.ToString(), - (string v) => v == null || v == "" ? null : (Nullable)int.Parse(v), + string (int? v) => (v == null ? null : ((object)v).ToString()), + int? (string v) => (v == null || v == "" ? null : ((int? )(int.Parse(v)))), convertsNulls: true), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Nullable v) => v == null ? null : v.ToString(), - (string v) => v == null || v == "" ? null : (Nullable)int.Parse(v), + string (int? v) => (v == null ? null : ((object)v).ToString()), + int? (string v) => (v == null || v == "" ? null : ((int? )(int.Parse(v)))), convertsNulls: true))); nullIntToNullStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -4160,19 +6328,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableBool", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableBool.SetGetter( + bool? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableBool(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableBool(entity).HasValue), + bool? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableBool(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableBool(instance).HasValue)); + nullableBool.SetSetter( + (CompiledModelTestBase.ManyTypes entity, bool? value) => ManyTypesUnsafeAccessors.NullableBool(entity) = value); + nullableBool.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, bool? value) => ManyTypesUnsafeAccessors.NullableBool(entity) = value); + nullableBool.SetAccessors( + bool? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableBool(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableBool(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableBool, 103), + bool? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableBool), + object (ValueBuffer valueBuffer) => valueBuffer[103]); + nullableBool.SetPropertyIndexes( + index: 103, + originalValueIndex: 103, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableBool.TypeMapping = MySqlBoolTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (bool)v1 == (bool)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((bool)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(bool)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (bool)v1 == (bool)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((bool)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(bool)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (bool)v1 == (bool)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((bool)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(bool)v : default(Nullable))); + comparer: new ValueComparer( + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), + keyComparer: new ValueComparer( + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), + providerValueComparer: new ValueComparer( + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v)); + nullableBool.SetComparer(new NullableValueComparer(nullableBool.TypeMapping.Comparer)); + nullableBool.SetKeyComparer(new NullableValueComparer(nullableBool.TypeMapping.KeyComparer)); nullableBool.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableBoolArray = runtimeEntityType.AddProperty( @@ -4180,39 +6371,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(bool?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableBoolArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableBoolArray.SetGetter( + bool? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableBoolArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableBoolArray(entity) == null, + bool? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableBoolArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableBoolArray(instance) == null); + nullableBoolArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, bool? [] value) => ManyTypesUnsafeAccessors.NullableBoolArray(entity) = value); + nullableBoolArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, bool? [] value) => ManyTypesUnsafeAccessors.NullableBoolArray(entity) = value); + nullableBoolArray.SetAccessors( + bool? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableBoolArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableBoolArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + bool? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableBoolArray, 104), + bool? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableBoolArray), + object (ValueBuffer valueBuffer) => valueBuffer[104]); + nullableBoolArray.SetPropertyIndexes( + index: 104, + originalValueIndex: 104, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableBoolArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (bool)v1 == (bool)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((bool)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(bool)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (bool)v1 == (bool)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((bool)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(bool)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonBoolReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonBoolReaderWriter.Instance), elementMapping: MySqlBoolTypeMapping.Default.Clone( comparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), keyComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), providerValueComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v))); + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v))); nullableBoolArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableBytes = runtimeEntityType.AddProperty( @@ -4221,19 +6433,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableBytes", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableBytes.SetGetter( + byte[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableBytes(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableBytes(entity) == null, + byte[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableBytes(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableBytes(instance) == null); + nullableBytes.SetSetter( + (CompiledModelTestBase.ManyTypes entity, byte[] value) => ManyTypesUnsafeAccessors.NullableBytes(entity) = value); + nullableBytes.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, byte[] value) => ManyTypesUnsafeAccessors.NullableBytes(entity) = value); + nullableBytes.SetAccessors( + byte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableBytes(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableBytes(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableBytes, 105), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableBytes), + object (ValueBuffer valueBuffer) => valueBuffer[105]); + nullableBytes.SetPropertyIndexes( + index: 105, + originalValueIndex: 105, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableBytes.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray())); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray())); nullableBytes.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableBytesArray = runtimeEntityType.AddProperty( @@ -4241,39 +6474,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(byte[][]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableBytesArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableBytesArray.SetGetter( + byte[][] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableBytesArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableBytesArray(entity) == null, + byte[][] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableBytesArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableBytesArray(instance) == null); + nullableBytesArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, byte[][] value) => ManyTypesUnsafeAccessors.NullableBytesArray(entity) = value); + nullableBytesArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, byte[][] value) => ManyTypesUnsafeAccessors.NullableBytesArray(entity) = value); + nullableBytesArray.SetAccessors( + byte[][] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableBytesArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[][] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableBytesArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[][] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableBytesArray, 106), + byte[][] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableBytesArray), + object (ValueBuffer valueBuffer) => valueBuffer[106]); + nullableBytesArray.SetPropertyIndexes( + index: 106, + originalValueIndex: 106, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableBytesArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( JsonByteArrayReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( JsonByteArrayReaderWriter.Instance), elementMapping: MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()))); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()))); nullableBytesArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableChar = runtimeEntityType.AddProperty( @@ -4282,30 +6536,53 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableChar", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableChar.SetGetter( + char? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableChar(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableChar(entity).HasValue), + char? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableChar(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableChar(instance).HasValue)); + nullableChar.SetSetter( + (CompiledModelTestBase.ManyTypes entity, char? value) => ManyTypesUnsafeAccessors.NullableChar(entity) = value); + nullableChar.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, char? value) => ManyTypesUnsafeAccessors.NullableChar(entity) = value); + nullableChar.SetAccessors( + char? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableChar(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableChar(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableChar, 107), + char? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableChar), + object (ValueBuffer valueBuffer) => valueBuffer[107]); + nullableChar.SetPropertyIndexes( + index: 107, + originalValueIndex: 107, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableChar.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (char)v1 == (char)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(char)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(char)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (char)v1 == (char)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(char)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(char)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ValueComparer( + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), + keyComparer: new ValueComparer( + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(1)", size: 1), converter: new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]), + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]))); + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])))); + nullableChar.SetComparer(new NullableValueComparer(nullableChar.TypeMapping.Comparer)); + nullableChar.SetKeyComparer(new NullableValueComparer(nullableChar.TypeMapping.KeyComparer)); nullableChar.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableCharArray = runtimeEntityType.AddProperty( @@ -4313,58 +6590,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(char?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableCharArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableCharArray.SetGetter( + char? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableCharArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableCharArray(entity) == null, + char? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableCharArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableCharArray(instance) == null); + nullableCharArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, char? [] value) => ManyTypesUnsafeAccessors.NullableCharArray(entity) = value); + nullableCharArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, char? [] value) => ManyTypesUnsafeAccessors.NullableCharArray(entity) = value); + nullableCharArray.SetAccessors( + char? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableCharArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableCharArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + char? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableCharArray, 108), + char? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableCharArray), + object (ValueBuffer valueBuffer) => valueBuffer[108]); + nullableCharArray.SetPropertyIndexes( + index: 108, + originalValueIndex: 108, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableCharArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (char)v1 == (char)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(char)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(char)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (char)v1 == (char)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(char)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(char)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0])))), + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0]))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]))), + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v), + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), keyComparer: new ValueComparer( - (char v1, char v2) => v1 == v2, - (char v) => (int)v, - (char v) => v), + bool (char v1, char v2) => v1 == v2, + int (char v) => ((int)(v)), + char (char v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(1)", size: 1), converter: new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0]), + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0])), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v), - (string v) => v.Length < 1 ? '\0' : v[0])))); + string (char v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v))), + char (string v) => (v.Length < 1 ? '\0' : v[0]))))); nullableCharArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableDateOnly = runtimeEntityType.AddProperty( @@ -4373,19 +6671,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDateOnly", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableDateOnly.SetGetter( + DateOnly? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDateOnly(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableDateOnly(entity).HasValue), + DateOnly? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDateOnly(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableDateOnly(instance).HasValue)); + nullableDateOnly.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly? value) => ManyTypesUnsafeAccessors.NullableDateOnly(entity) = value); + nullableDateOnly.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly? value) => ManyTypesUnsafeAccessors.NullableDateOnly(entity) = value); + nullableDateOnly.SetAccessors( + DateOnly? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDateOnly(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDateOnly(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableDateOnly, 109), + DateOnly? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableDateOnly), + object (ValueBuffer valueBuffer) => valueBuffer[109]); + nullableDateOnly.SetPropertyIndexes( + index: 109, + originalValueIndex: 109, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableDateOnly.TypeMapping = MySqlDateTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateOnly)v1 == (DateOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateOnly)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateOnly)v1 == (DateOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateOnly)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateOnly)v1 == (DateOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateOnly)v : default(Nullable))); + comparer: new ValueComparer( + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), + keyComparer: new ValueComparer( + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), + providerValueComparer: new ValueComparer( + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v)); + nullableDateOnly.SetComparer(new NullableValueComparer(nullableDateOnly.TypeMapping.Comparer)); + nullableDateOnly.SetKeyComparer(new NullableValueComparer(nullableDateOnly.TypeMapping.KeyComparer)); nullableDateOnly.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableDateOnlyArray = runtimeEntityType.AddProperty( @@ -4393,39 +6714,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(DateOnly?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDateOnlyArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableDateOnlyArray.SetGetter( + DateOnly? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDateOnlyArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDateOnlyArray(entity) == null, + DateOnly? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDateOnlyArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDateOnlyArray(instance) == null); + nullableDateOnlyArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly? [] value) => ManyTypesUnsafeAccessors.NullableDateOnlyArray(entity) = value); + nullableDateOnlyArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateOnly? [] value) => ManyTypesUnsafeAccessors.NullableDateOnlyArray(entity) = value); + nullableDateOnlyArray.SetAccessors( + DateOnly? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDateOnlyArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDateOnlyArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateOnly? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableDateOnlyArray, 110), + DateOnly? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableDateOnlyArray), + object (ValueBuffer valueBuffer) => valueBuffer[110]); + nullableDateOnlyArray.SetPropertyIndexes( + index: 110, + originalValueIndex: 110, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableDateOnlyArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateOnly)v1 == (DateOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateOnly)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateOnly)v1 == (DateOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateOnly)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonDateOnlyReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonDateOnlyReaderWriter.Instance), elementMapping: MySqlDateTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v), + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), keyComparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v), + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), providerValueComparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v))); + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v))); nullableDateOnlyArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableDateTime = runtimeEntityType.AddProperty( @@ -4434,22 +6776,45 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDateTime", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableDateTime.SetGetter( + DateTime? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDateTime(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableDateTime(entity).HasValue), + DateTime? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDateTime(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableDateTime(instance).HasValue)); + nullableDateTime.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime? value) => ManyTypesUnsafeAccessors.NullableDateTime(entity) = value); + nullableDateTime.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime? value) => ManyTypesUnsafeAccessors.NullableDateTime(entity) = value); + nullableDateTime.SetAccessors( + DateTime? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDateTime(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDateTime(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableDateTime, 111), + DateTime? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableDateTime), + object (ValueBuffer valueBuffer) => valueBuffer[111]); + nullableDateTime.SetPropertyIndexes( + index: 111, + originalValueIndex: 111, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableDateTime.TypeMapping = MySqlDateTimeTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateTime)v1 == (DateTime)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateTime)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateTime)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateTime)v1 == (DateTime)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateTime)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateTime)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateTime)v1 == (DateTime)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateTime)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateTime)v : default(Nullable)), + comparer: new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), + keyComparer: new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), + providerValueComparer: new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", precision: 6)); + nullableDateTime.SetComparer(new NullableValueComparer(nullableDateTime.TypeMapping.Comparer)); + nullableDateTime.SetKeyComparer(new NullableValueComparer(nullableDateTime.TypeMapping.KeyComparer)); nullableDateTime.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableDateTimeArray = runtimeEntityType.AddProperty( @@ -4457,39 +6822,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(DateTime?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDateTimeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableDateTimeArray.SetGetter( + DateTime? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDateTimeArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDateTimeArray(entity) == null, + DateTime? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDateTimeArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDateTimeArray(instance) == null); + nullableDateTimeArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime? [] value) => ManyTypesUnsafeAccessors.NullableDateTimeArray(entity) = value); + nullableDateTimeArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, DateTime? [] value) => ManyTypesUnsafeAccessors.NullableDateTimeArray(entity) = value); + nullableDateTimeArray.SetAccessors( + DateTime? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDateTimeArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDateTimeArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + DateTime? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableDateTimeArray, 112), + DateTime? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableDateTimeArray), + object (ValueBuffer valueBuffer) => valueBuffer[112]); + nullableDateTimeArray.SetPropertyIndexes( + index: 112, + originalValueIndex: 112, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableDateTimeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateTime)v1 == (DateTime)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateTime)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateTime)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (DateTime)v1 == (DateTime)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((DateTime)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(DateTime)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonDateTimeReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonDateTimeReaderWriter.Instance), elementMapping: MySqlDateTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), keyComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), providerValueComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", precision: 6))); @@ -4501,19 +6887,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDecimal", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableDecimal.SetGetter( + decimal? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDecimal(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableDecimal(entity).HasValue), + decimal? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDecimal(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableDecimal(instance).HasValue)); + nullableDecimal.SetSetter( + (CompiledModelTestBase.ManyTypes entity, decimal? value) => ManyTypesUnsafeAccessors.NullableDecimal(entity) = value); + nullableDecimal.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, decimal? value) => ManyTypesUnsafeAccessors.NullableDecimal(entity) = value); + nullableDecimal.SetAccessors( + decimal? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDecimal(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDecimal(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableDecimal, 113), + decimal? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableDecimal), + object (ValueBuffer valueBuffer) => valueBuffer[113]); + nullableDecimal.SetPropertyIndexes( + index: 113, + originalValueIndex: 113, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableDecimal.TypeMapping = MySqlDecimalTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (decimal)v1 == (decimal)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((decimal)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(decimal)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (decimal)v1 == (decimal)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((decimal)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(decimal)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (decimal)v1 == (decimal)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((decimal)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(decimal)v : default(Nullable))); + comparer: new ValueComparer( + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), + keyComparer: new ValueComparer( + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), + providerValueComparer: new ValueComparer( + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v)); + nullableDecimal.SetComparer(new NullableValueComparer(nullableDecimal.TypeMapping.Comparer)); + nullableDecimal.SetKeyComparer(new NullableValueComparer(nullableDecimal.TypeMapping.KeyComparer)); nullableDecimal.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableDecimalArray = runtimeEntityType.AddProperty( @@ -4521,39 +6930,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(decimal?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDecimalArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableDecimalArray.SetGetter( + decimal? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDecimalArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDecimalArray(entity) == null, + decimal? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDecimalArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDecimalArray(instance) == null); + nullableDecimalArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, decimal? [] value) => ManyTypesUnsafeAccessors.NullableDecimalArray(entity) = value); + nullableDecimalArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, decimal? [] value) => ManyTypesUnsafeAccessors.NullableDecimalArray(entity) = value); + nullableDecimalArray.SetAccessors( + decimal? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDecimalArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDecimalArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + decimal? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableDecimalArray, 114), + decimal? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableDecimalArray), + object (ValueBuffer valueBuffer) => valueBuffer[114]); + nullableDecimalArray.SetPropertyIndexes( + index: 114, + originalValueIndex: 114, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableDecimalArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (decimal)v1 == (decimal)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((decimal)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(decimal)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (decimal)v1 == (decimal)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((decimal)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(decimal)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonDecimalReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonDecimalReaderWriter.Instance), elementMapping: MySqlDecimalTypeMapping.Default.Clone( comparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), keyComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), providerValueComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v))); + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v))); nullableDecimalArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableDouble = runtimeEntityType.AddProperty( @@ -4562,19 +6992,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDouble", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableDouble.SetGetter( + double? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDouble(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableDouble(entity).HasValue), + double? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDouble(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableDouble(instance).HasValue)); + nullableDouble.SetSetter( + (CompiledModelTestBase.ManyTypes entity, double? value) => ManyTypesUnsafeAccessors.NullableDouble(entity) = value); + nullableDouble.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, double? value) => ManyTypesUnsafeAccessors.NullableDouble(entity) = value); + nullableDouble.SetAccessors( + double? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDouble(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDouble(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableDouble, 115), + double? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableDouble), + object (ValueBuffer valueBuffer) => valueBuffer[115]); + nullableDouble.SetPropertyIndexes( + index: 115, + originalValueIndex: 115, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableDouble.TypeMapping = MySqlDoubleTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((double)v1).Equals((double)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((double)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(double)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((double)v1).Equals((double)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((double)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(double)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((double)v1).Equals((double)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((double)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(double)v : default(Nullable))); + comparer: new ValueComparer( + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), + keyComparer: new ValueComparer( + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), + providerValueComparer: new ValueComparer( + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v)); + nullableDouble.SetComparer(new NullableValueComparer(nullableDouble.TypeMapping.Comparer)); + nullableDouble.SetKeyComparer(new NullableValueComparer(nullableDouble.TypeMapping.KeyComparer)); nullableDouble.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableDoubleArray = runtimeEntityType.AddProperty( @@ -4582,39 +7035,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(double?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDoubleArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableDoubleArray.SetGetter( + double? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDoubleArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableDoubleArray(entity) == null, + double? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDoubleArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableDoubleArray(instance) == null); + nullableDoubleArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, double? [] value) => ManyTypesUnsafeAccessors.NullableDoubleArray(entity) = value); + nullableDoubleArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, double? [] value) => ManyTypesUnsafeAccessors.NullableDoubleArray(entity) = value); + nullableDoubleArray.SetAccessors( + double? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDoubleArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableDoubleArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + double? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableDoubleArray, 116), + double? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableDoubleArray), + object (ValueBuffer valueBuffer) => valueBuffer[116]); + nullableDoubleArray.SetPropertyIndexes( + index: 116, + originalValueIndex: 116, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableDoubleArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((double)v1).Equals((double)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((double)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(double)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((double)v1).Equals((double)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((double)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(double)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonDoubleReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonDoubleReaderWriter.Instance), elementMapping: MySqlDoubleTypeMapping.Default.Clone( comparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), keyComparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), providerValueComparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v))); + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v))); nullableDoubleArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum16 = runtimeEntityType.AddProperty( @@ -4623,27 +7097,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnum16.SetGetter( + CompiledModelTestBase.Enum16? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnum16(entity).HasValue), + CompiledModelTestBase.Enum16? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnum16(instance).HasValue)); + nullableEnum16.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16? value) => ManyTypesUnsafeAccessors.NullableEnum16(entity) = (value == null ? value : ((CompiledModelTestBase.Enum16? )(((CompiledModelTestBase.Enum16)(value)))))); + nullableEnum16.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16? value) => ManyTypesUnsafeAccessors.NullableEnum16(entity) = (value == null ? value : ((CompiledModelTestBase.Enum16? )(((CompiledModelTestBase.Enum16)(value)))))); + nullableEnum16.SetAccessors( + CompiledModelTestBase.Enum16? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum16, 117), + CompiledModelTestBase.Enum16? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum16), + object (ValueBuffer valueBuffer) => valueBuffer[117]); + nullableEnum16.SetPropertyIndexes( + index: 117, + originalValueIndex: 117, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum16.TypeMapping = MySqlShortTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value))); + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))))); + nullableEnum16.SetComparer(new NullableValueComparer(nullableEnum16.TypeMapping.Comparer)); + nullableEnum16.SetKeyComparer(new NullableValueComparer(nullableEnum16.TypeMapping.KeyComparer)); nullableEnum16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum16Array = runtimeEntityType.AddProperty( @@ -4651,55 +7148,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum16?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum16Array.SetGetter( + CompiledModelTestBase.Enum16? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16Array(entity) == null, + CompiledModelTestBase.Enum16? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16Array(instance) == null); + nullableEnum16Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16? [] value) => ManyTypesUnsafeAccessors.NullableEnum16Array(entity) = value); + nullableEnum16Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16? [] value) => ManyTypesUnsafeAccessors.NullableEnum16Array(entity) = value); + nullableEnum16Array.SetAccessors( + CompiledModelTestBase.Enum16? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum16Array, 118), + CompiledModelTestBase.Enum16? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum16Array), + object (ValueBuffer valueBuffer) => valueBuffer[118]); + nullableEnum16Array.SetPropertyIndexes( + index: 118, + originalValueIndex: 118, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum16Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))))), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))); + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))); nullableEnum16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum16AsString = runtimeEntityType.AddProperty( @@ -4708,27 +7226,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnum16AsString.SetGetter( + CompiledModelTestBase.Enum16? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnum16AsString(entity).HasValue), + CompiledModelTestBase.Enum16? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnum16AsString(instance).HasValue)); + nullableEnum16AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16? value) => ManyTypesUnsafeAccessors.NullableEnum16AsString(entity) = (value == null ? value : ((CompiledModelTestBase.Enum16? )(((CompiledModelTestBase.Enum16)(value)))))); + nullableEnum16AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16? value) => ManyTypesUnsafeAccessors.NullableEnum16AsString(entity) = (value == null ? value : ((CompiledModelTestBase.Enum16? )(((CompiledModelTestBase.Enum16)(value)))))); + nullableEnum16AsString.SetAccessors( + CompiledModelTestBase.Enum16? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum16AsString, 119), + CompiledModelTestBase.Enum16? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum16AsString), + object (ValueBuffer valueBuffer) => valueBuffer[119]); + nullableEnum16AsString.SetPropertyIndexes( + index: 119, + originalValueIndex: 119, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum16AsString.TypeMapping = MySqlShortTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value))); + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))))); + nullableEnum16AsString.SetComparer(new NullableValueComparer(nullableEnum16AsString.TypeMapping.Comparer)); + nullableEnum16AsString.SetKeyComparer(new NullableValueComparer(nullableEnum16AsString.TypeMapping.KeyComparer)); nullableEnum16AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum16AsStringArray = runtimeEntityType.AddProperty( @@ -4736,55 +7277,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum16?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum16AsStringArray.SetGetter( + CompiledModelTestBase.Enum16? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16AsStringArray(entity) == null, + CompiledModelTestBase.Enum16? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16AsStringArray(instance) == null); + nullableEnum16AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16? [] value) => ManyTypesUnsafeAccessors.NullableEnum16AsStringArray(entity) = value); + nullableEnum16AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum16? [] value) => ManyTypesUnsafeAccessors.NullableEnum16AsStringArray(entity) = value); + nullableEnum16AsStringArray.SetAccessors( + CompiledModelTestBase.Enum16? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum16? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum16AsStringArray, 120), + CompiledModelTestBase.Enum16? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum16AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[120]); + nullableEnum16AsStringArray.SetPropertyIndexes( + index: 120, + originalValueIndex: 120, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum16AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))))), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))); + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))); nullableEnum16AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum16AsStringCollection = runtimeEntityType.AddProperty( @@ -4792,55 +7354,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum16AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16AsStringCollection(instance) == null); + nullableEnum16AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum16AsStringCollection(entity) = value); + nullableEnum16AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum16AsStringCollection(entity) = value); + nullableEnum16AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnum16AsStringCollection, 121), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnum16AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[121]); + nullableEnum16AsStringCollection.SetPropertyIndexes( + index: 121, + originalValueIndex: 121, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum16AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum16>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum16>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum16>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum16>( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum16>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum16>( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))))), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))); + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))); nullableEnum16AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum16Collection = runtimeEntityType.AddProperty( @@ -4848,55 +7431,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum16Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum16Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum16Collection(instance) == null); + nullableEnum16Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum16Collection(entity) = value); + nullableEnum16Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum16Collection(entity) = value); + nullableEnum16Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum16Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnum16Collection, 122), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnum16Collection), + object (ValueBuffer valueBuffer) => valueBuffer[122]); + nullableEnum16Collection.SetPropertyIndexes( + index: 122, + originalValueIndex: 122, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum16Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum16)v1, (object)(CompiledModelTestBase.Enum16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum16)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum16>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum16>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum16>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum16>( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum16>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum16>( new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value))), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))))), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum16 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum16 v) => v), + bool (CompiledModelTestBase.Enum16 v1, CompiledModelTestBase.Enum16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum16 (CompiledModelTestBase.Enum16 v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value), + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum16 value) => (short)value, - (short value) => (CompiledModelTestBase.Enum16)value)))); + short (CompiledModelTestBase.Enum16 value) => ((short)(value)), + CompiledModelTestBase.Enum16 (short value) => ((CompiledModelTestBase.Enum16)(value)))))); nullableEnum16Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum32 = runtimeEntityType.AddProperty( @@ -4905,27 +7509,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnum32.SetGetter( + CompiledModelTestBase.Enum32? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnum32(entity).HasValue), + CompiledModelTestBase.Enum32? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnum32(instance).HasValue)); + nullableEnum32.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32? value) => ManyTypesUnsafeAccessors.NullableEnum32(entity) = (value == null ? value : ((CompiledModelTestBase.Enum32? )(((CompiledModelTestBase.Enum32)(value)))))); + nullableEnum32.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32? value) => ManyTypesUnsafeAccessors.NullableEnum32(entity) = (value == null ? value : ((CompiledModelTestBase.Enum32? )(((CompiledModelTestBase.Enum32)(value)))))); + nullableEnum32.SetAccessors( + CompiledModelTestBase.Enum32? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum32, 123), + CompiledModelTestBase.Enum32? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum32), + object (ValueBuffer valueBuffer) => valueBuffer[123]); + nullableEnum32.SetPropertyIndexes( + index: 123, + originalValueIndex: 123, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum32.TypeMapping = MySqlIntTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))); + nullableEnum32.SetComparer(new NullableValueComparer(nullableEnum32.TypeMapping.Comparer)); + nullableEnum32.SetKeyComparer(new NullableValueComparer(nullableEnum32.TypeMapping.KeyComparer)); nullableEnum32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum32Array = runtimeEntityType.AddProperty( @@ -4933,55 +7560,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum32?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum32Array.SetGetter( + CompiledModelTestBase.Enum32? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32Array(entity) == null, + CompiledModelTestBase.Enum32? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32Array(instance) == null); + nullableEnum32Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32? [] value) => ManyTypesUnsafeAccessors.NullableEnum32Array(entity) = value); + nullableEnum32Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32? [] value) => ManyTypesUnsafeAccessors.NullableEnum32Array(entity) = value); + nullableEnum32Array.SetAccessors( + CompiledModelTestBase.Enum32? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum32Array, 124), + CompiledModelTestBase.Enum32? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum32Array), + object (ValueBuffer valueBuffer) => valueBuffer[124]); + nullableEnum32Array.SetPropertyIndexes( + index: 124, + originalValueIndex: 124, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum32Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))), elementMapping: MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))); nullableEnum32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum32AsString = runtimeEntityType.AddProperty( @@ -4990,27 +7638,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnum32AsString.SetGetter( + CompiledModelTestBase.Enum32? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnum32AsString(entity).HasValue), + CompiledModelTestBase.Enum32? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnum32AsString(instance).HasValue)); + nullableEnum32AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32? value) => ManyTypesUnsafeAccessors.NullableEnum32AsString(entity) = (value == null ? value : ((CompiledModelTestBase.Enum32? )(((CompiledModelTestBase.Enum32)(value)))))); + nullableEnum32AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32? value) => ManyTypesUnsafeAccessors.NullableEnum32AsString(entity) = (value == null ? value : ((CompiledModelTestBase.Enum32? )(((CompiledModelTestBase.Enum32)(value)))))); + nullableEnum32AsString.SetAccessors( + CompiledModelTestBase.Enum32? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum32AsString, 125), + CompiledModelTestBase.Enum32? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum32AsString), + object (ValueBuffer valueBuffer) => valueBuffer[125]); + nullableEnum32AsString.SetPropertyIndexes( + index: 125, + originalValueIndex: 125, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum32AsString.TypeMapping = MySqlIntTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))); + nullableEnum32AsString.SetComparer(new NullableValueComparer(nullableEnum32AsString.TypeMapping.Comparer)); + nullableEnum32AsString.SetKeyComparer(new NullableValueComparer(nullableEnum32AsString.TypeMapping.KeyComparer)); nullableEnum32AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum32AsStringArray = runtimeEntityType.AddProperty( @@ -5018,55 +7689,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum32?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum32AsStringArray.SetGetter( + CompiledModelTestBase.Enum32? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32AsStringArray(entity) == null, + CompiledModelTestBase.Enum32? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32AsStringArray(instance) == null); + nullableEnum32AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32? [] value) => ManyTypesUnsafeAccessors.NullableEnum32AsStringArray(entity) = value); + nullableEnum32AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum32? [] value) => ManyTypesUnsafeAccessors.NullableEnum32AsStringArray(entity) = value); + nullableEnum32AsStringArray.SetAccessors( + CompiledModelTestBase.Enum32? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum32? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum32AsStringArray, 126), + CompiledModelTestBase.Enum32? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum32AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[126]); + nullableEnum32AsStringArray.SetPropertyIndexes( + index: 126, + originalValueIndex: 126, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum32AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))), elementMapping: MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))); nullableEnum32AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum32AsStringCollection = runtimeEntityType.AddProperty( @@ -5074,55 +7766,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum32AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32AsStringCollection(instance) == null); + nullableEnum32AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum32AsStringCollection(entity) = value); + nullableEnum32AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum32AsStringCollection(entity) = value); + nullableEnum32AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnum32AsStringCollection, 127), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnum32AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[127]); + nullableEnum32AsStringCollection.SetPropertyIndexes( + index: 127, + originalValueIndex: 127, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum32AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum32>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum32>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum32>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum32>( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum32>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum32>( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))), elementMapping: MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))); nullableEnum32AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum32Collection = runtimeEntityType.AddProperty( @@ -5130,55 +7843,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum32Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum32Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum32Collection(instance) == null); + nullableEnum32Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum32Collection(entity) = value); + nullableEnum32Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum32Collection(entity) = value); + nullableEnum32Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum32Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnum32Collection, 128), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnum32Collection), + object (ValueBuffer valueBuffer) => valueBuffer[128]); + nullableEnum32Collection.SetPropertyIndexes( + index: 128, + originalValueIndex: 128, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum32Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum32)v1, (object)(CompiledModelTestBase.Enum32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum32)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum32>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum32>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum32>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum32>( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum32>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum32>( new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value))), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))))), elementMapping: MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum32 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum32 v) => v), + bool (CompiledModelTestBase.Enum32 v1, CompiledModelTestBase.Enum32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum32 (CompiledModelTestBase.Enum32 v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value), + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum32 value) => (int)value, - (int value) => (CompiledModelTestBase.Enum32)value)))); + int (CompiledModelTestBase.Enum32 value) => ((int)(value)), + CompiledModelTestBase.Enum32 (int value) => ((CompiledModelTestBase.Enum32)(value)))))); nullableEnum32Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum64 = runtimeEntityType.AddProperty( @@ -5187,27 +7921,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnum64.SetGetter( + CompiledModelTestBase.Enum64? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnum64(entity).HasValue), + CompiledModelTestBase.Enum64? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnum64(instance).HasValue)); + nullableEnum64.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64? value) => ManyTypesUnsafeAccessors.NullableEnum64(entity) = (value == null ? value : ((CompiledModelTestBase.Enum64? )(((CompiledModelTestBase.Enum64)(value)))))); + nullableEnum64.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64? value) => ManyTypesUnsafeAccessors.NullableEnum64(entity) = (value == null ? value : ((CompiledModelTestBase.Enum64? )(((CompiledModelTestBase.Enum64)(value)))))); + nullableEnum64.SetAccessors( + CompiledModelTestBase.Enum64? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum64, 129), + CompiledModelTestBase.Enum64? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum64), + object (ValueBuffer valueBuffer) => valueBuffer[129]); + nullableEnum64.SetPropertyIndexes( + index: 129, + originalValueIndex: 129, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum64.TypeMapping = MySqlLongTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value))); + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))))); + nullableEnum64.SetComparer(new NullableValueComparer(nullableEnum64.TypeMapping.Comparer)); + nullableEnum64.SetKeyComparer(new NullableValueComparer(nullableEnum64.TypeMapping.KeyComparer)); nullableEnum64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum64Array = runtimeEntityType.AddProperty( @@ -5215,55 +7972,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum64?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum64Array.SetGetter( + CompiledModelTestBase.Enum64? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64Array(entity) == null, + CompiledModelTestBase.Enum64? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64Array(instance) == null); + nullableEnum64Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64? [] value) => ManyTypesUnsafeAccessors.NullableEnum64Array(entity) = value); + nullableEnum64Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64? [] value) => ManyTypesUnsafeAccessors.NullableEnum64Array(entity) = value); + nullableEnum64Array.SetAccessors( + CompiledModelTestBase.Enum64? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum64Array, 130), + CompiledModelTestBase.Enum64? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum64Array), + object (ValueBuffer valueBuffer) => valueBuffer[130]); + nullableEnum64Array.SetPropertyIndexes( + index: 130, + originalValueIndex: 130, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum64Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))))), elementMapping: MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))); + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))); nullableEnum64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum64AsString = runtimeEntityType.AddProperty( @@ -5272,27 +8050,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnum64AsString.SetGetter( + CompiledModelTestBase.Enum64? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnum64AsString(entity).HasValue), + CompiledModelTestBase.Enum64? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnum64AsString(instance).HasValue)); + nullableEnum64AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64? value) => ManyTypesUnsafeAccessors.NullableEnum64AsString(entity) = (value == null ? value : ((CompiledModelTestBase.Enum64? )(((CompiledModelTestBase.Enum64)(value)))))); + nullableEnum64AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64? value) => ManyTypesUnsafeAccessors.NullableEnum64AsString(entity) = (value == null ? value : ((CompiledModelTestBase.Enum64? )(((CompiledModelTestBase.Enum64)(value)))))); + nullableEnum64AsString.SetAccessors( + CompiledModelTestBase.Enum64? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum64AsString, 131), + CompiledModelTestBase.Enum64? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum64AsString), + object (ValueBuffer valueBuffer) => valueBuffer[131]); + nullableEnum64AsString.SetPropertyIndexes( + index: 131, + originalValueIndex: 131, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum64AsString.TypeMapping = MySqlLongTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value))); + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))))); + nullableEnum64AsString.SetComparer(new NullableValueComparer(nullableEnum64AsString.TypeMapping.Comparer)); + nullableEnum64AsString.SetKeyComparer(new NullableValueComparer(nullableEnum64AsString.TypeMapping.KeyComparer)); nullableEnum64AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum64AsStringArray = runtimeEntityType.AddProperty( @@ -5300,55 +8101,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum64?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum64AsStringArray.SetGetter( + CompiledModelTestBase.Enum64? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64AsStringArray(entity) == null, + CompiledModelTestBase.Enum64? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64AsStringArray(instance) == null); + nullableEnum64AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64? [] value) => ManyTypesUnsafeAccessors.NullableEnum64AsStringArray(entity) = value); + nullableEnum64AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum64? [] value) => ManyTypesUnsafeAccessors.NullableEnum64AsStringArray(entity) = value); + nullableEnum64AsStringArray.SetAccessors( + CompiledModelTestBase.Enum64? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum64? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum64AsStringArray, 132), + CompiledModelTestBase.Enum64? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum64AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[132]); + nullableEnum64AsStringArray.SetPropertyIndexes( + index: 132, + originalValueIndex: 132, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum64AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))))), elementMapping: MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))); + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))); nullableEnum64AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum64AsStringCollection = runtimeEntityType.AddProperty( @@ -5356,55 +8178,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum64AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64AsStringCollection(instance) == null); + nullableEnum64AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum64AsStringCollection(entity) = value); + nullableEnum64AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum64AsStringCollection(entity) = value); + nullableEnum64AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnum64AsStringCollection, 133), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnum64AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[133]); + nullableEnum64AsStringCollection.SetPropertyIndexes( + index: 133, + originalValueIndex: 133, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum64AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum64>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum64>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum64>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum64>( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum64>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum64>( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))))), elementMapping: MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))); + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))); nullableEnum64AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum64Collection = runtimeEntityType.AddProperty( @@ -5412,55 +8255,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum64Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum64Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum64Collection(instance) == null); + nullableEnum64Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum64Collection(entity) = value); + nullableEnum64Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum64Collection(entity) = value); + nullableEnum64Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum64Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnum64Collection, 134), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnum64Collection), + object (ValueBuffer valueBuffer) => valueBuffer[134]); + nullableEnum64Collection.SetPropertyIndexes( + index: 134, + originalValueIndex: 134, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum64Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum64)v1, (object)(CompiledModelTestBase.Enum64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum64)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum64>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum64>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum64>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum64>( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum64>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum64>( new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value))), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))))), elementMapping: MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum64 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum64 v) => v), + bool (CompiledModelTestBase.Enum64 v1, CompiledModelTestBase.Enum64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum64 (CompiledModelTestBase.Enum64 v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value), + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum64 value) => (long)value, - (long value) => (CompiledModelTestBase.Enum64)value)))); + long (CompiledModelTestBase.Enum64 value) => ((long)(value)), + CompiledModelTestBase.Enum64 (long value) => ((CompiledModelTestBase.Enum64)(value)))))); nullableEnum64Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum8 = runtimeEntityType.AddProperty( @@ -5469,27 +8333,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnum8.SetGetter( + CompiledModelTestBase.Enum8? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnum8(entity).HasValue), + CompiledModelTestBase.Enum8? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnum8(instance).HasValue)); + nullableEnum8.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8? value) => ManyTypesUnsafeAccessors.NullableEnum8(entity) = (value == null ? value : ((CompiledModelTestBase.Enum8? )(((CompiledModelTestBase.Enum8)(value)))))); + nullableEnum8.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8? value) => ManyTypesUnsafeAccessors.NullableEnum8(entity) = (value == null ? value : ((CompiledModelTestBase.Enum8? )(((CompiledModelTestBase.Enum8)(value)))))); + nullableEnum8.SetAccessors( + CompiledModelTestBase.Enum8? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum8, 135), + CompiledModelTestBase.Enum8? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum8), + object (ValueBuffer valueBuffer) => valueBuffer[135]); + nullableEnum8.SetPropertyIndexes( + index: 135, + originalValueIndex: 135, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum8.TypeMapping = MySqlSByteTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value))); + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))))); + nullableEnum8.SetComparer(new NullableValueComparer(nullableEnum8.TypeMapping.Comparer)); + nullableEnum8.SetKeyComparer(new NullableValueComparer(nullableEnum8.TypeMapping.KeyComparer)); nullableEnum8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum8Array = runtimeEntityType.AddProperty( @@ -5497,55 +8384,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum8?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum8Array.SetGetter( + CompiledModelTestBase.Enum8? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8Array(entity) == null, + CompiledModelTestBase.Enum8? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8Array(instance) == null); + nullableEnum8Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8? [] value) => ManyTypesUnsafeAccessors.NullableEnum8Array(entity) = value); + nullableEnum8Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8? [] value) => ManyTypesUnsafeAccessors.NullableEnum8Array(entity) = value); + nullableEnum8Array.SetAccessors( + CompiledModelTestBase.Enum8? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum8Array, 136), + CompiledModelTestBase.Enum8? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum8Array), + object (ValueBuffer valueBuffer) => valueBuffer[136]); + nullableEnum8Array.SetPropertyIndexes( + index: 136, + originalValueIndex: 136, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum8Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))))), elementMapping: MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))); + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))); nullableEnum8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum8AsString = runtimeEntityType.AddProperty( @@ -5554,27 +8462,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnum8AsString.SetGetter( + CompiledModelTestBase.Enum8? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnum8AsString(entity).HasValue), + CompiledModelTestBase.Enum8? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnum8AsString(instance).HasValue)); + nullableEnum8AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8? value) => ManyTypesUnsafeAccessors.NullableEnum8AsString(entity) = (value == null ? value : ((CompiledModelTestBase.Enum8? )(((CompiledModelTestBase.Enum8)(value)))))); + nullableEnum8AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8? value) => ManyTypesUnsafeAccessors.NullableEnum8AsString(entity) = (value == null ? value : ((CompiledModelTestBase.Enum8? )(((CompiledModelTestBase.Enum8)(value)))))); + nullableEnum8AsString.SetAccessors( + CompiledModelTestBase.Enum8? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum8AsString, 137), + CompiledModelTestBase.Enum8? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum8AsString), + object (ValueBuffer valueBuffer) => valueBuffer[137]); + nullableEnum8AsString.SetPropertyIndexes( + index: 137, + originalValueIndex: 137, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum8AsString.TypeMapping = MySqlSByteTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value))); + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))))); + nullableEnum8AsString.SetComparer(new NullableValueComparer(nullableEnum8AsString.TypeMapping.Comparer)); + nullableEnum8AsString.SetKeyComparer(new NullableValueComparer(nullableEnum8AsString.TypeMapping.KeyComparer)); nullableEnum8AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum8AsStringArray = runtimeEntityType.AddProperty( @@ -5582,55 +8513,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Enum8?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum8AsStringArray.SetGetter( + CompiledModelTestBase.Enum8? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8AsStringArray(entity) == null, + CompiledModelTestBase.Enum8? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8AsStringArray(instance) == null); + nullableEnum8AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8? [] value) => ManyTypesUnsafeAccessors.NullableEnum8AsStringArray(entity) = value); + nullableEnum8AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.Enum8? [] value) => ManyTypesUnsafeAccessors.NullableEnum8AsStringArray(entity) = value); + nullableEnum8AsStringArray.SetAccessors( + CompiledModelTestBase.Enum8? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.Enum8? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnum8AsStringArray, 138), + CompiledModelTestBase.Enum8? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnum8AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[138]); + nullableEnum8AsStringArray.SetPropertyIndexes( + index: 138, + originalValueIndex: 138, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum8AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))))), elementMapping: MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))); + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))); nullableEnum8AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum8AsStringCollection = runtimeEntityType.AddProperty( @@ -5638,55 +8590,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum8AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8AsStringCollection(instance) == null); + nullableEnum8AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum8AsStringCollection(entity) = value); + nullableEnum8AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum8AsStringCollection(entity) = value); + nullableEnum8AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnum8AsStringCollection, 139), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnum8AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[139]); + nullableEnum8AsStringCollection.SetPropertyIndexes( + index: 139, + originalValueIndex: 139, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum8AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum8>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum8>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum8>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum8>( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum8>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum8>( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))))), elementMapping: MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))); + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))); nullableEnum8AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnum8Collection = runtimeEntityType.AddProperty( @@ -5694,55 +8667,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum8Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnum8Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnum8Collection(instance) == null); + nullableEnum8Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum8Collection(entity) = value); + nullableEnum8Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnum8Collection(entity) = value); + nullableEnum8Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnum8Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnum8Collection, 140), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnum8Collection), + object (ValueBuffer valueBuffer) => valueBuffer[140]); + nullableEnum8Collection.SetPropertyIndexes( + index: 140, + originalValueIndex: 140, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnum8Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.Enum8)v1, (object)(CompiledModelTestBase.Enum8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.Enum8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.Enum8)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum8>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.Enum8>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum8>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum8>( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.Enum8>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.Enum8>( new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value))), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))))), elementMapping: MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.Enum8 v) => v.GetHashCode(), - (CompiledModelTestBase.Enum8 v) => v), + bool (CompiledModelTestBase.Enum8 v1, CompiledModelTestBase.Enum8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.Enum8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.Enum8 (CompiledModelTestBase.Enum8 v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value), + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonSByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.Enum8 value) => (sbyte)value, - (sbyte value) => (CompiledModelTestBase.Enum8)value)))); + sbyte (CompiledModelTestBase.Enum8 value) => ((sbyte)(value)), + CompiledModelTestBase.Enum8 (sbyte value) => ((CompiledModelTestBase.Enum8)(value)))))); nullableEnum8Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU16 = runtimeEntityType.AddProperty( @@ -5751,27 +8745,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnumU16.SetGetter( + CompiledModelTestBase.EnumU16? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnumU16(entity).HasValue), + CompiledModelTestBase.EnumU16? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnumU16(instance).HasValue)); + nullableEnumU16.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16? value) => ManyTypesUnsafeAccessors.NullableEnumU16(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU16? )(((CompiledModelTestBase.EnumU16)(value)))))); + nullableEnumU16.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16? value) => ManyTypesUnsafeAccessors.NullableEnumU16(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU16? )(((CompiledModelTestBase.EnumU16)(value)))))); + nullableEnumU16.SetAccessors( + CompiledModelTestBase.EnumU16? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU16, 141), + CompiledModelTestBase.EnumU16? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU16), + object (ValueBuffer valueBuffer) => valueBuffer[141]); + nullableEnumU16.SetPropertyIndexes( + index: 141, + originalValueIndex: 141, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU16.TypeMapping = MySqlUShortTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value))); + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))))); + nullableEnumU16.SetComparer(new NullableValueComparer(nullableEnumU16.TypeMapping.Comparer)); + nullableEnumU16.SetKeyComparer(new NullableValueComparer(nullableEnumU16.TypeMapping.KeyComparer)); nullableEnumU16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU16Array = runtimeEntityType.AddProperty( @@ -5779,55 +8796,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU16?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU16Array.SetGetter( + CompiledModelTestBase.EnumU16? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16Array(entity) == null, + CompiledModelTestBase.EnumU16? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16Array(instance) == null); + nullableEnumU16Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16? [] value) => ManyTypesUnsafeAccessors.NullableEnumU16Array(entity) = value); + nullableEnumU16Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16? [] value) => ManyTypesUnsafeAccessors.NullableEnumU16Array(entity) = value); + nullableEnumU16Array.SetAccessors( + CompiledModelTestBase.EnumU16? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU16Array, 142), + CompiledModelTestBase.EnumU16? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU16Array), + object (ValueBuffer valueBuffer) => valueBuffer[142]); + nullableEnumU16Array.SetPropertyIndexes( + index: 142, + originalValueIndex: 142, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU16Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))))), elementMapping: MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))); + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))); nullableEnumU16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU16AsString = runtimeEntityType.AddProperty( @@ -5836,27 +8874,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnumU16AsString.SetGetter( + CompiledModelTestBase.EnumU16? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnumU16AsString(entity).HasValue), + CompiledModelTestBase.EnumU16? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnumU16AsString(instance).HasValue)); + nullableEnumU16AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16? value) => ManyTypesUnsafeAccessors.NullableEnumU16AsString(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU16? )(((CompiledModelTestBase.EnumU16)(value)))))); + nullableEnumU16AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16? value) => ManyTypesUnsafeAccessors.NullableEnumU16AsString(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU16? )(((CompiledModelTestBase.EnumU16)(value)))))); + nullableEnumU16AsString.SetAccessors( + CompiledModelTestBase.EnumU16? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU16AsString, 143), + CompiledModelTestBase.EnumU16? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU16AsString), + object (ValueBuffer valueBuffer) => valueBuffer[143]); + nullableEnumU16AsString.SetPropertyIndexes( + index: 143, + originalValueIndex: 143, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU16AsString.TypeMapping = MySqlUShortTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value))); + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))))); + nullableEnumU16AsString.SetComparer(new NullableValueComparer(nullableEnumU16AsString.TypeMapping.Comparer)); + nullableEnumU16AsString.SetKeyComparer(new NullableValueComparer(nullableEnumU16AsString.TypeMapping.KeyComparer)); nullableEnumU16AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU16AsStringArray = runtimeEntityType.AddProperty( @@ -5864,55 +8925,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU16?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU16AsStringArray.SetGetter( + CompiledModelTestBase.EnumU16? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringArray(entity) == null, + CompiledModelTestBase.EnumU16? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringArray(instance) == null); + nullableEnumU16AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16? [] value) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringArray(entity) = value); + nullableEnumU16AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU16? [] value) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringArray(entity) = value); + nullableEnumU16AsStringArray.SetAccessors( + CompiledModelTestBase.EnumU16? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU16? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU16AsStringArray, 144), + CompiledModelTestBase.EnumU16? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU16AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[144]); + nullableEnumU16AsStringArray.SetPropertyIndexes( + index: 144, + originalValueIndex: 144, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU16AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))))), elementMapping: MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))); + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))); nullableEnumU16AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU16AsStringCollection = runtimeEntityType.AddProperty( @@ -5920,55 +9002,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU16AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringCollection(instance) == null); + nullableEnumU16AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringCollection(entity) = value); + nullableEnumU16AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringCollection(entity) = value); + nullableEnumU16AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnumU16AsStringCollection, 145), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnumU16AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[145]); + nullableEnumU16AsStringCollection.SetPropertyIndexes( + index: 145, + originalValueIndex: 145, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU16AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU16>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU16>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU16>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU16>( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU16>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU16>( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))))), elementMapping: MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))); + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))); nullableEnumU16AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU16Collection = runtimeEntityType.AddProperty( @@ -5976,55 +9079,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU16Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU16Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU16Collection(instance) == null); + nullableEnumU16Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU16Collection(entity) = value); + nullableEnumU16Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU16Collection(entity) = value); + nullableEnumU16Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU16Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnumU16Collection, 146), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnumU16Collection), + object (ValueBuffer valueBuffer) => valueBuffer[146]); + nullableEnumU16Collection.SetPropertyIndexes( + index: 146, + originalValueIndex: 146, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU16Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU16)v1, (object)(CompiledModelTestBase.EnumU16)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU16)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU16)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU16>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU16>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU16>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU16>( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU16>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU16>( new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value))), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))))), elementMapping: MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU16 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU16 v) => v), + bool (CompiledModelTestBase.EnumU16 v1, CompiledModelTestBase.EnumU16 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU16 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU16 (CompiledModelTestBase.EnumU16 v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value), + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt16ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU16 value) => (ushort)value, - (ushort value) => (CompiledModelTestBase.EnumU16)value)))); + ushort (CompiledModelTestBase.EnumU16 value) => ((ushort)(value)), + CompiledModelTestBase.EnumU16 (ushort value) => ((CompiledModelTestBase.EnumU16)(value)))))); nullableEnumU16Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU32 = runtimeEntityType.AddProperty( @@ -6033,27 +9157,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnumU32.SetGetter( + CompiledModelTestBase.EnumU32? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnumU32(entity).HasValue), + CompiledModelTestBase.EnumU32? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnumU32(instance).HasValue)); + nullableEnumU32.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32? value) => ManyTypesUnsafeAccessors.NullableEnumU32(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU32? )(((CompiledModelTestBase.EnumU32)(value)))))); + nullableEnumU32.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32? value) => ManyTypesUnsafeAccessors.NullableEnumU32(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU32? )(((CompiledModelTestBase.EnumU32)(value)))))); + nullableEnumU32.SetAccessors( + CompiledModelTestBase.EnumU32? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU32, 147), + CompiledModelTestBase.EnumU32? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU32), + object (ValueBuffer valueBuffer) => valueBuffer[147]); + nullableEnumU32.SetPropertyIndexes( + index: 147, + originalValueIndex: 147, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU32.TypeMapping = MySqlUIntTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value))); + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))))); + nullableEnumU32.SetComparer(new NullableValueComparer(nullableEnumU32.TypeMapping.Comparer)); + nullableEnumU32.SetKeyComparer(new NullableValueComparer(nullableEnumU32.TypeMapping.KeyComparer)); nullableEnumU32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU32Array = runtimeEntityType.AddProperty( @@ -6061,55 +9208,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU32?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU32Array.SetGetter( + CompiledModelTestBase.EnumU32? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32Array(entity) == null, + CompiledModelTestBase.EnumU32? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32Array(instance) == null); + nullableEnumU32Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32? [] value) => ManyTypesUnsafeAccessors.NullableEnumU32Array(entity) = value); + nullableEnumU32Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32? [] value) => ManyTypesUnsafeAccessors.NullableEnumU32Array(entity) = value); + nullableEnumU32Array.SetAccessors( + CompiledModelTestBase.EnumU32? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU32Array, 148), + CompiledModelTestBase.EnumU32? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU32Array), + object (ValueBuffer valueBuffer) => valueBuffer[148]); + nullableEnumU32Array.SetPropertyIndexes( + index: 148, + originalValueIndex: 148, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU32Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))))), elementMapping: MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))); + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))); nullableEnumU32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU32AsString = runtimeEntityType.AddProperty( @@ -6118,27 +9286,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnumU32AsString.SetGetter( + CompiledModelTestBase.EnumU32? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnumU32AsString(entity).HasValue), + CompiledModelTestBase.EnumU32? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnumU32AsString(instance).HasValue)); + nullableEnumU32AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32? value) => ManyTypesUnsafeAccessors.NullableEnumU32AsString(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU32? )(((CompiledModelTestBase.EnumU32)(value)))))); + nullableEnumU32AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32? value) => ManyTypesUnsafeAccessors.NullableEnumU32AsString(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU32? )(((CompiledModelTestBase.EnumU32)(value)))))); + nullableEnumU32AsString.SetAccessors( + CompiledModelTestBase.EnumU32? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU32AsString, 149), + CompiledModelTestBase.EnumU32? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU32AsString), + object (ValueBuffer valueBuffer) => valueBuffer[149]); + nullableEnumU32AsString.SetPropertyIndexes( + index: 149, + originalValueIndex: 149, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU32AsString.TypeMapping = MySqlUIntTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value))); + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))))); + nullableEnumU32AsString.SetComparer(new NullableValueComparer(nullableEnumU32AsString.TypeMapping.Comparer)); + nullableEnumU32AsString.SetKeyComparer(new NullableValueComparer(nullableEnumU32AsString.TypeMapping.KeyComparer)); nullableEnumU32AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU32AsStringArray = runtimeEntityType.AddProperty( @@ -6146,55 +9337,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU32?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU32AsStringArray.SetGetter( + CompiledModelTestBase.EnumU32? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringArray(entity) == null, + CompiledModelTestBase.EnumU32? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringArray(instance) == null); + nullableEnumU32AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32? [] value) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringArray(entity) = value); + nullableEnumU32AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU32? [] value) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringArray(entity) = value); + nullableEnumU32AsStringArray.SetAccessors( + CompiledModelTestBase.EnumU32? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU32? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU32AsStringArray, 150), + CompiledModelTestBase.EnumU32? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU32AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[150]); + nullableEnumU32AsStringArray.SetPropertyIndexes( + index: 150, + originalValueIndex: 150, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU32AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))))), elementMapping: MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))); + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))); nullableEnumU32AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU32AsStringCollection = runtimeEntityType.AddProperty( @@ -6202,55 +9414,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU32AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringCollection(instance) == null); + nullableEnumU32AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringCollection(entity) = value); + nullableEnumU32AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringCollection(entity) = value); + nullableEnumU32AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnumU32AsStringCollection, 151), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnumU32AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[151]); + nullableEnumU32AsStringCollection.SetPropertyIndexes( + index: 151, + originalValueIndex: 151, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU32AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU32>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU32>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU32>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU32>( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU32>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU32>( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))))), elementMapping: MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))); + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))); nullableEnumU32AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU32Collection = runtimeEntityType.AddProperty( @@ -6258,55 +9491,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU32Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU32Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU32Collection(instance) == null); + nullableEnumU32Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU32Collection(entity) = value); + nullableEnumU32Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU32Collection(entity) = value); + nullableEnumU32Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU32Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnumU32Collection, 152), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnumU32Collection), + object (ValueBuffer valueBuffer) => valueBuffer[152]); + nullableEnumU32Collection.SetPropertyIndexes( + index: 152, + originalValueIndex: 152, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU32Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU32)v1, (object)(CompiledModelTestBase.EnumU32)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU32)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU32)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU32>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU32>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU32>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU32>( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU32>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU32>( new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value))), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))))), elementMapping: MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU32 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU32 v) => v), + bool (CompiledModelTestBase.EnumU32 v1, CompiledModelTestBase.EnumU32 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU32 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU32 (CompiledModelTestBase.EnumU32 v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value), + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU32 value) => (uint)value, - (uint value) => (CompiledModelTestBase.EnumU32)value)))); + uint (CompiledModelTestBase.EnumU32 value) => ((uint)(value)), + CompiledModelTestBase.EnumU32 (uint value) => ((CompiledModelTestBase.EnumU32)(value)))))); nullableEnumU32Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU64 = runtimeEntityType.AddProperty( @@ -6315,27 +9569,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnumU64.SetGetter( + CompiledModelTestBase.EnumU64? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnumU64(entity).HasValue), + CompiledModelTestBase.EnumU64? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnumU64(instance).HasValue)); + nullableEnumU64.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64? value) => ManyTypesUnsafeAccessors.NullableEnumU64(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU64? )(((CompiledModelTestBase.EnumU64)(value)))))); + nullableEnumU64.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64? value) => ManyTypesUnsafeAccessors.NullableEnumU64(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU64? )(((CompiledModelTestBase.EnumU64)(value)))))); + nullableEnumU64.SetAccessors( + CompiledModelTestBase.EnumU64? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU64, 153), + CompiledModelTestBase.EnumU64? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU64), + object (ValueBuffer valueBuffer) => valueBuffer[153]); + nullableEnumU64.SetPropertyIndexes( + index: 153, + originalValueIndex: 153, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU64.TypeMapping = MySqlULongTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value))); + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))))); + nullableEnumU64.SetComparer(new NullableValueComparer(nullableEnumU64.TypeMapping.Comparer)); + nullableEnumU64.SetKeyComparer(new NullableValueComparer(nullableEnumU64.TypeMapping.KeyComparer)); nullableEnumU64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU64Array = runtimeEntityType.AddProperty( @@ -6343,55 +9620,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU64?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU64Array.SetGetter( + CompiledModelTestBase.EnumU64? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64Array(entity) == null, + CompiledModelTestBase.EnumU64? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64Array(instance) == null); + nullableEnumU64Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64? [] value) => ManyTypesUnsafeAccessors.NullableEnumU64Array(entity) = value); + nullableEnumU64Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64? [] value) => ManyTypesUnsafeAccessors.NullableEnumU64Array(entity) = value); + nullableEnumU64Array.SetAccessors( + CompiledModelTestBase.EnumU64? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU64Array, 154), + CompiledModelTestBase.EnumU64? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU64Array), + object (ValueBuffer valueBuffer) => valueBuffer[154]); + nullableEnumU64Array.SetPropertyIndexes( + index: 154, + originalValueIndex: 154, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU64Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))))), elementMapping: MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))); + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))); nullableEnumU64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU64AsString = runtimeEntityType.AddProperty( @@ -6400,27 +9698,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnumU64AsString.SetGetter( + CompiledModelTestBase.EnumU64? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnumU64AsString(entity).HasValue), + CompiledModelTestBase.EnumU64? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnumU64AsString(instance).HasValue)); + nullableEnumU64AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64? value) => ManyTypesUnsafeAccessors.NullableEnumU64AsString(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU64? )(((CompiledModelTestBase.EnumU64)(value)))))); + nullableEnumU64AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64? value) => ManyTypesUnsafeAccessors.NullableEnumU64AsString(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU64? )(((CompiledModelTestBase.EnumU64)(value)))))); + nullableEnumU64AsString.SetAccessors( + CompiledModelTestBase.EnumU64? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU64AsString, 155), + CompiledModelTestBase.EnumU64? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU64AsString), + object (ValueBuffer valueBuffer) => valueBuffer[155]); + nullableEnumU64AsString.SetPropertyIndexes( + index: 155, + originalValueIndex: 155, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU64AsString.TypeMapping = MySqlULongTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value))); + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))))); + nullableEnumU64AsString.SetComparer(new NullableValueComparer(nullableEnumU64AsString.TypeMapping.Comparer)); + nullableEnumU64AsString.SetKeyComparer(new NullableValueComparer(nullableEnumU64AsString.TypeMapping.KeyComparer)); nullableEnumU64AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU64AsStringArray = runtimeEntityType.AddProperty( @@ -6428,55 +9749,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU64?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU64AsStringArray.SetGetter( + CompiledModelTestBase.EnumU64? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringArray(entity) == null, + CompiledModelTestBase.EnumU64? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringArray(instance) == null); + nullableEnumU64AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64? [] value) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringArray(entity) = value); + nullableEnumU64AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU64? [] value) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringArray(entity) = value); + nullableEnumU64AsStringArray.SetAccessors( + CompiledModelTestBase.EnumU64? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU64? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU64AsStringArray, 156), + CompiledModelTestBase.EnumU64? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU64AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[156]); + nullableEnumU64AsStringArray.SetPropertyIndexes( + index: 156, + originalValueIndex: 156, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU64AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))))), elementMapping: MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))); + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))); nullableEnumU64AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU64AsStringCollection = runtimeEntityType.AddProperty( @@ -6484,55 +9826,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU64AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringCollection(instance) == null); + nullableEnumU64AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringCollection(entity) = value); + nullableEnumU64AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringCollection(entity) = value); + nullableEnumU64AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnumU64AsStringCollection, 157), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnumU64AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[157]); + nullableEnumU64AsStringCollection.SetPropertyIndexes( + index: 157, + originalValueIndex: 157, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU64AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU64>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU64>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU64>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU64>( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU64>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU64>( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))))), elementMapping: MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))); + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))); nullableEnumU64AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU64Collection = runtimeEntityType.AddProperty( @@ -6540,55 +9903,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU64Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU64Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU64Collection(instance) == null); + nullableEnumU64Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU64Collection(entity) = value); + nullableEnumU64Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU64Collection(entity) = value); + nullableEnumU64Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU64Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnumU64Collection, 158), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnumU64Collection), + object (ValueBuffer valueBuffer) => valueBuffer[158]); + nullableEnumU64Collection.SetPropertyIndexes( + index: 158, + originalValueIndex: 158, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU64Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU64)v1, (object)(CompiledModelTestBase.EnumU64)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU64)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU64)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU64>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU64>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU64>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU64>( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU64>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU64>( new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value))), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))))), elementMapping: MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU64 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU64 v) => v), + bool (CompiledModelTestBase.EnumU64 v1, CompiledModelTestBase.EnumU64 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU64 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU64 (CompiledModelTestBase.EnumU64 v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value), + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt64ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU64 value) => (ulong)value, - (ulong value) => (CompiledModelTestBase.EnumU64)value)))); + ulong (CompiledModelTestBase.EnumU64 value) => ((ulong)(value)), + CompiledModelTestBase.EnumU64 (ulong value) => ((CompiledModelTestBase.EnumU64)(value)))))); nullableEnumU64Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU8 = runtimeEntityType.AddProperty( @@ -6597,27 +9981,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnumU8.SetGetter( + CompiledModelTestBase.EnumU8? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnumU8(entity).HasValue), + CompiledModelTestBase.EnumU8? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnumU8(instance).HasValue)); + nullableEnumU8.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8? value) => ManyTypesUnsafeAccessors.NullableEnumU8(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU8? )(((CompiledModelTestBase.EnumU8)(value)))))); + nullableEnumU8.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8? value) => ManyTypesUnsafeAccessors.NullableEnumU8(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU8? )(((CompiledModelTestBase.EnumU8)(value)))))); + nullableEnumU8.SetAccessors( + CompiledModelTestBase.EnumU8? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU8, 159), + CompiledModelTestBase.EnumU8? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU8), + object (ValueBuffer valueBuffer) => valueBuffer[159]); + nullableEnumU8.SetPropertyIndexes( + index: 159, + originalValueIndex: 159, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU8.TypeMapping = MySqlByteTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value))); + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))))); + nullableEnumU8.SetComparer(new NullableValueComparer(nullableEnumU8.TypeMapping.Comparer)); + nullableEnumU8.SetKeyComparer(new NullableValueComparer(nullableEnumU8.TypeMapping.KeyComparer)); nullableEnumU8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU8Array = runtimeEntityType.AddProperty( @@ -6625,55 +10032,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU8?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU8Array.SetGetter( + CompiledModelTestBase.EnumU8? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8Array(entity) == null, + CompiledModelTestBase.EnumU8? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8Array(instance) == null); + nullableEnumU8Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8? [] value) => ManyTypesUnsafeAccessors.NullableEnumU8Array(entity) = value); + nullableEnumU8Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8? [] value) => ManyTypesUnsafeAccessors.NullableEnumU8Array(entity) = value); + nullableEnumU8Array.SetAccessors( + CompiledModelTestBase.EnumU8? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU8Array, 160), + CompiledModelTestBase.EnumU8? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU8Array), + object (ValueBuffer valueBuffer) => valueBuffer[160]); + nullableEnumU8Array.SetPropertyIndexes( + index: 160, + originalValueIndex: 160, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU8Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))))), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))); + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))); nullableEnumU8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU8AsString = runtimeEntityType.AddProperty( @@ -6682,27 +10110,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableEnumU8AsString.SetGetter( + CompiledModelTestBase.EnumU8? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8AsString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableEnumU8AsString(entity).HasValue), + CompiledModelTestBase.EnumU8? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8AsString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableEnumU8AsString(instance).HasValue)); + nullableEnumU8AsString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8? value) => ManyTypesUnsafeAccessors.NullableEnumU8AsString(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU8? )(((CompiledModelTestBase.EnumU8)(value)))))); + nullableEnumU8AsString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8? value) => ManyTypesUnsafeAccessors.NullableEnumU8AsString(entity) = (value == null ? value : ((CompiledModelTestBase.EnumU8? )(((CompiledModelTestBase.EnumU8)(value)))))); + nullableEnumU8AsString.SetAccessors( + CompiledModelTestBase.EnumU8? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8AsString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU8AsString, 161), + CompiledModelTestBase.EnumU8? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU8AsString), + object (ValueBuffer valueBuffer) => valueBuffer[161]); + nullableEnumU8AsString.SetPropertyIndexes( + index: 161, + originalValueIndex: 161, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU8AsString.TypeMapping = MySqlByteTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value))); + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))))); + nullableEnumU8AsString.SetComparer(new NullableValueComparer(nullableEnumU8AsString.TypeMapping.Comparer)); + nullableEnumU8AsString.SetKeyComparer(new NullableValueComparer(nullableEnumU8AsString.TypeMapping.KeyComparer)); nullableEnumU8AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU8AsStringArray = runtimeEntityType.AddProperty( @@ -6710,55 +10161,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.EnumU8?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU8AsStringArray.SetGetter( + CompiledModelTestBase.EnumU8? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringArray(entity) == null, + CompiledModelTestBase.EnumU8? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringArray(instance) == null); + nullableEnumU8AsStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8? [] value) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringArray(entity) = value); + nullableEnumU8AsStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, CompiledModelTestBase.EnumU8? [] value) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringArray(entity) = value); + nullableEnumU8AsStringArray.SetAccessors( + CompiledModelTestBase.EnumU8? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + CompiledModelTestBase.EnumU8? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableEnumU8AsStringArray, 162), + CompiledModelTestBase.EnumU8? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableEnumU8AsStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[162]); + nullableEnumU8AsStringArray.SetPropertyIndexes( + index: 162, + originalValueIndex: 162, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU8AsStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))))), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))); + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))); nullableEnumU8AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU8AsStringCollection = runtimeEntityType.AddProperty( @@ -6766,55 +10238,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU8AsStringCollection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringCollection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringCollection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringCollection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringCollection(instance) == null); + nullableEnumU8AsStringCollection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringCollection(entity) = value); + nullableEnumU8AsStringCollection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringCollection(entity) = value); + nullableEnumU8AsStringCollection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8AsStringCollection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnumU8AsStringCollection, 163), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnumU8AsStringCollection), + object (ValueBuffer valueBuffer) => valueBuffer[163]); + nullableEnumU8AsStringCollection.SetPropertyIndexes( + index: 163, + originalValueIndex: 163, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU8AsStringCollection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU8>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU8>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU8>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU8>( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU8>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU8>( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))))), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))); + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))); nullableEnumU8AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableEnumU8Collection = runtimeEntityType.AddProperty( @@ -6822,55 +10315,76 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(List), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU8Collection.SetGetter( + List (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8Collection(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableEnumU8Collection(entity) == null, + List (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8Collection(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableEnumU8Collection(instance) == null); + nullableEnumU8Collection.SetSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU8Collection(entity) = value); + nullableEnumU8Collection.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, List value) => ManyTypesUnsafeAccessors.NullableEnumU8Collection(entity) = value); + nullableEnumU8Collection.SetAccessors( + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableEnumU8Collection(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(nullableEnumU8Collection, 164), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(nullableEnumU8Collection), + object (ValueBuffer valueBuffer) => valueBuffer[164]); + nullableEnumU8Collection.SetPropertyIndexes( + index: 164, + originalValueIndex: 164, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableEnumU8Collection.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.EnumU8)v1, (object)(CompiledModelTestBase.EnumU8)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.EnumU8)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.EnumU8)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU8>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v))), + keyComparer: new ListOfNullableValueTypesComparer, CompiledModelTestBase.EnumU8>(new NullableValueComparer(new ValueComparer( + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU8>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU8>( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter, List, CompiledModelTestBase.EnumU8>( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter, CompiledModelTestBase.EnumU8>( new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value))), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))))), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.EnumU8 v) => v.GetHashCode(), - (CompiledModelTestBase.EnumU8 v) => v), + bool (CompiledModelTestBase.EnumU8 v1, CompiledModelTestBase.EnumU8 v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.EnumU8 v) => ((object)v).GetHashCode(), + CompiledModelTestBase.EnumU8 (CompiledModelTestBase.EnumU8 v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), converter: new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value), + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.EnumU8 value) => (byte)value, - (byte value) => (CompiledModelTestBase.EnumU8)value)))); + byte (CompiledModelTestBase.EnumU8 value) => ((byte)(value)), + CompiledModelTestBase.EnumU8 (byte value) => ((CompiledModelTestBase.EnumU8)(value)))))); nullableEnumU8Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableFloat = runtimeEntityType.AddProperty( @@ -6879,19 +10393,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableFloat", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableFloat.SetGetter( + float? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableFloat(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableFloat(entity).HasValue), + float? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableFloat(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableFloat(instance).HasValue)); + nullableFloat.SetSetter( + (CompiledModelTestBase.ManyTypes entity, float? value) => ManyTypesUnsafeAccessors.NullableFloat(entity) = value); + nullableFloat.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, float? value) => ManyTypesUnsafeAccessors.NullableFloat(entity) = value); + nullableFloat.SetAccessors( + float? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableFloat(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + float? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableFloat(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + float? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableFloat, 165), + float? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableFloat), + object (ValueBuffer valueBuffer) => valueBuffer[165]); + nullableFloat.SetPropertyIndexes( + index: 165, + originalValueIndex: 165, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableFloat.TypeMapping = MySqlFloatTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((float)v1).Equals((float)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((float)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(float)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((float)v1).Equals((float)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((float)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(float)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((float)v1).Equals((float)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((float)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(float)v : default(Nullable))); + comparer: new ValueComparer( + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v), + keyComparer: new ValueComparer( + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v), + providerValueComparer: new ValueComparer( + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v)); + nullableFloat.SetComparer(new NullableValueComparer(nullableFloat.TypeMapping.Comparer)); + nullableFloat.SetKeyComparer(new NullableValueComparer(nullableFloat.TypeMapping.KeyComparer)); nullableFloat.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableFloatArray = runtimeEntityType.AddProperty( @@ -6899,39 +10436,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(float?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableFloatArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableFloatArray.SetGetter( + float? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableFloatArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableFloatArray(entity) == null, + float? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableFloatArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableFloatArray(instance) == null); + nullableFloatArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, float? [] value) => ManyTypesUnsafeAccessors.NullableFloatArray(entity) = value); + nullableFloatArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, float? [] value) => ManyTypesUnsafeAccessors.NullableFloatArray(entity) = value); + nullableFloatArray.SetAccessors( + float? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableFloatArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + float? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableFloatArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + float? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableFloatArray, 166), + float? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableFloatArray), + object (ValueBuffer valueBuffer) => valueBuffer[166]); + nullableFloatArray.SetPropertyIndexes( + index: 166, + originalValueIndex: 166, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableFloatArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((float)v1).Equals((float)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((float)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(float)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && ((float)v1).Equals((float)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((float)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(float)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonFloatReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonFloatReaderWriter.Instance), elementMapping: MySqlFloatTypeMapping.Default.Clone( comparer: new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v), + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v), keyComparer: new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v), + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v), providerValueComparer: new ValueComparer( - (float v1, float v2) => v1.Equals(v2), - (float v) => v.GetHashCode(), - (float v) => v))); + bool (float v1, float v2) => v1.Equals(v2), + int (float v) => ((object)v).GetHashCode(), + float (float v) => v))); nullableFloatArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableGuid = runtimeEntityType.AddProperty( @@ -6940,19 +10498,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableGuid", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableGuid.SetGetter( + Guid? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableGuid(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableGuid(entity).HasValue), + Guid? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableGuid(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableGuid(instance).HasValue)); + nullableGuid.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Guid? value) => ManyTypesUnsafeAccessors.NullableGuid(entity) = value); + nullableGuid.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Guid? value) => ManyTypesUnsafeAccessors.NullableGuid(entity) = value); + nullableGuid.SetAccessors( + Guid? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableGuid(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableGuid(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableGuid, 167), + Guid? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableGuid), + object (ValueBuffer valueBuffer) => valueBuffer[167]); + nullableGuid.SetPropertyIndexes( + index: 167, + originalValueIndex: 167, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableGuid.TypeMapping = MySqlGuidTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (Guid)v1 == (Guid)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((Guid)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(Guid)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (Guid)v1 == (Guid)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((Guid)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(Guid)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (Guid)v1 == (Guid)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((Guid)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(Guid)v : default(Nullable))); + comparer: new ValueComparer( + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), + keyComparer: new ValueComparer( + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), + providerValueComparer: new ValueComparer( + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)); + nullableGuid.SetComparer(new NullableValueComparer(nullableGuid.TypeMapping.Comparer)); + nullableGuid.SetKeyComparer(new NullableValueComparer(nullableGuid.TypeMapping.KeyComparer)); nullableGuid.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableGuidArray = runtimeEntityType.AddProperty( @@ -6960,39 +10541,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(Guid?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableGuidArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableGuidArray.SetGetter( + Guid? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableGuidArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableGuidArray(entity) == null, + Guid? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableGuidArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableGuidArray(instance) == null); + nullableGuidArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Guid? [] value) => ManyTypesUnsafeAccessors.NullableGuidArray(entity) = value); + nullableGuidArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Guid? [] value) => ManyTypesUnsafeAccessors.NullableGuidArray(entity) = value); + nullableGuidArray.SetAccessors( + Guid? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableGuidArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableGuidArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Guid? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableGuidArray, 168), + Guid? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableGuidArray), + object (ValueBuffer valueBuffer) => valueBuffer[168]); + nullableGuidArray.SetPropertyIndexes( + index: 168, + originalValueIndex: 168, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableGuidArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (Guid)v1 == (Guid)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((Guid)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(Guid)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (Guid)v1 == (Guid)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((Guid)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(Guid)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonGuidReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonGuidReaderWriter.Instance), elementMapping: MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v))); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v))); nullableGuidArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableIPAddress = runtimeEntityType.AddProperty( @@ -7001,30 +10603,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableIPAddress", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableIPAddress.SetGetter( + IPAddress (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableIPAddress(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableIPAddress(entity) == null, + IPAddress (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableIPAddress(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableIPAddress(instance) == null); + nullableIPAddress.SetSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress value) => ManyTypesUnsafeAccessors.NullableIPAddress(entity) = value); + nullableIPAddress.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress value) => ManyTypesUnsafeAccessors.NullableIPAddress(entity) = value); + nullableIPAddress.SetAccessors( + IPAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableIPAddress(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableIPAddress(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableIPAddress, 169), + IPAddress (InternalEntityEntry entry) => entry.GetCurrentValue(nullableIPAddress), + object (ValueBuffer valueBuffer) => valueBuffer[169]); + nullableIPAddress.SetPropertyIndexes( + index: 169, + originalValueIndex: 169, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableIPAddress.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))); nullableIPAddress.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableIPAddressArray = runtimeEntityType.AddProperty( @@ -7032,58 +10655,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(IPAddress[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableIPAddressArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableIPAddressArray.SetGetter( + IPAddress[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableIPAddressArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableIPAddressArray(entity) == null, + IPAddress[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableIPAddressArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableIPAddressArray(instance) == null); + nullableIPAddressArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress[] value) => ManyTypesUnsafeAccessors.NullableIPAddressArray(entity) = value); + nullableIPAddressArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, IPAddress[] value) => ManyTypesUnsafeAccessors.NullableIPAddressArray(entity) = value); + nullableIPAddressArray.SetAccessors( + IPAddress[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableIPAddressArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableIPAddressArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableIPAddressArray, 170), + IPAddress[] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableIPAddressArray), + object (ValueBuffer valueBuffer) => valueBuffer[170]); + nullableIPAddressArray.SetPropertyIndexes( + index: 170, + originalValueIndex: 170, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableIPAddressArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); nullableIPAddressArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableInt16 = runtimeEntityType.AddProperty( @@ -7092,19 +10736,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableInt16.SetGetter( + short? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt16(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableInt16(entity).HasValue), + short? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt16(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableInt16(instance).HasValue)); + nullableInt16.SetSetter( + (CompiledModelTestBase.ManyTypes entity, short? value) => ManyTypesUnsafeAccessors.NullableInt16(entity) = value); + nullableInt16.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, short? value) => ManyTypesUnsafeAccessors.NullableInt16(entity) = value); + nullableInt16.SetAccessors( + short? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + short? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + short? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableInt16, 171), + short? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableInt16), + object (ValueBuffer valueBuffer) => valueBuffer[171]); + nullableInt16.SetPropertyIndexes( + index: 171, + originalValueIndex: 171, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableInt16.TypeMapping = MySqlShortTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (short)v1 == (short)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(short)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(short)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (short)v1 == (short)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(short)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(short)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (short)v1 == (short)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(short)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(short)v : default(Nullable))); + comparer: new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), + keyComparer: new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), + providerValueComparer: new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)); + nullableInt16.SetComparer(new NullableValueComparer(nullableInt16.TypeMapping.Comparer)); + nullableInt16.SetKeyComparer(new NullableValueComparer(nullableInt16.TypeMapping.KeyComparer)); nullableInt16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableInt16Array = runtimeEntityType.AddProperty( @@ -7112,39 +10779,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(short?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableInt16Array.SetGetter( + short? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt16Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt16Array(entity) == null, + short? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt16Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt16Array(instance) == null); + nullableInt16Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, short? [] value) => ManyTypesUnsafeAccessors.NullableInt16Array(entity) = value); + nullableInt16Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, short? [] value) => ManyTypesUnsafeAccessors.NullableInt16Array(entity) = value); + nullableInt16Array.SetAccessors( + short? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + short? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + short? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableInt16Array, 172), + short? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableInt16Array), + object (ValueBuffer valueBuffer) => valueBuffer[172]); + nullableInt16Array.SetPropertyIndexes( + index: 172, + originalValueIndex: 172, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableInt16Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (short)v1 == (short)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(short)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(short)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (short)v1 == (short)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(short)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(short)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonInt16ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonInt16ReaderWriter.Instance), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), keyComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v))); + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v))); nullableInt16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableInt32 = runtimeEntityType.AddProperty( @@ -7153,19 +10841,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableInt32.SetGetter( + int? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt32(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableInt32(entity).HasValue), + int? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt32(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableInt32(instance).HasValue)); + nullableInt32.SetSetter( + (CompiledModelTestBase.ManyTypes entity, int? value) => ManyTypesUnsafeAccessors.NullableInt32(entity) = value); + nullableInt32.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, int? value) => ManyTypesUnsafeAccessors.NullableInt32(entity) = value); + nullableInt32.SetAccessors( + int? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableInt32, 173), + int? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableInt32), + object (ValueBuffer valueBuffer) => valueBuffer[173]); + nullableInt32.SetPropertyIndexes( + index: 173, + originalValueIndex: 173, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableInt32.TypeMapping = MySqlIntTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (int)v1 == (int)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(int)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (int)v1 == (int)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(int)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (int)v1 == (int)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(int)v : default(Nullable))); + comparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), + keyComparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), + providerValueComparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); + nullableInt32.SetComparer(new NullableValueComparer(nullableInt32.TypeMapping.Comparer)); + nullableInt32.SetKeyComparer(new NullableValueComparer(nullableInt32.TypeMapping.KeyComparer)); nullableInt32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableInt32Array = runtimeEntityType.AddProperty( @@ -7173,39 +10884,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(int?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableInt32Array.SetGetter( + int? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt32Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt32Array(entity) == null, + int? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt32Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt32Array(instance) == null); + nullableInt32Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, int? [] value) => ManyTypesUnsafeAccessors.NullableInt32Array(entity) = value); + nullableInt32Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, int? [] value) => ManyTypesUnsafeAccessors.NullableInt32Array(entity) = value); + nullableInt32Array.SetAccessors( + int? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + int? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableInt32Array, 174), + int? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableInt32Array), + object (ValueBuffer valueBuffer) => valueBuffer[174]); + nullableInt32Array.SetPropertyIndexes( + index: 174, + originalValueIndex: 174, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableInt32Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (int)v1 == (int)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(int)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (int)v1 == (int)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(int)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonInt32ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonInt32ReaderWriter.Instance), elementMapping: MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v))); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v))); nullableInt32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableInt64 = runtimeEntityType.AddProperty( @@ -7214,19 +10946,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableInt64.SetGetter( + long? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt64(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableInt64(entity).HasValue), + long? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt64(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableInt64(instance).HasValue)); + nullableInt64.SetSetter( + (CompiledModelTestBase.ManyTypes entity, long? value) => ManyTypesUnsafeAccessors.NullableInt64(entity) = value); + nullableInt64.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, long? value) => ManyTypesUnsafeAccessors.NullableInt64(entity) = value); + nullableInt64.SetAccessors( + long? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + long? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + long? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableInt64, 175), + long? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableInt64), + object (ValueBuffer valueBuffer) => valueBuffer[175]); + nullableInt64.SetPropertyIndexes( + index: 175, + originalValueIndex: 175, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableInt64.TypeMapping = MySqlLongTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (long)v1 == (long)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((long)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(long)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (long)v1 == (long)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((long)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(long)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (long)v1 == (long)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((long)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(long)v : default(Nullable))); + comparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + keyComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + providerValueComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + nullableInt64.SetComparer(new NullableValueComparer(nullableInt64.TypeMapping.Comparer)); + nullableInt64.SetKeyComparer(new NullableValueComparer(nullableInt64.TypeMapping.KeyComparer)); nullableInt64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableInt64Array = runtimeEntityType.AddProperty( @@ -7234,39 +10989,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(long?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableInt64Array.SetGetter( + long? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt64Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt64Array(entity) == null, + long? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt64Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt64Array(instance) == null); + nullableInt64Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, long? [] value) => ManyTypesUnsafeAccessors.NullableInt64Array(entity) = value); + nullableInt64Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, long? [] value) => ManyTypesUnsafeAccessors.NullableInt64Array(entity) = value); + nullableInt64Array.SetAccessors( + long? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + long? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + long? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableInt64Array, 176), + long? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableInt64Array), + object (ValueBuffer valueBuffer) => valueBuffer[176]); + nullableInt64Array.SetPropertyIndexes( + index: 176, + originalValueIndex: 176, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableInt64Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (long)v1 == (long)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((long)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(long)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (long)v1 == (long)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((long)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(long)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonInt64ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonInt64ReaderWriter.Instance), elementMapping: MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), keyComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v))); + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v))); nullableInt64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableInt8 = runtimeEntityType.AddProperty( @@ -7275,19 +11051,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableInt8.SetGetter( + sbyte? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt8(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableInt8(entity).HasValue), + sbyte? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt8(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableInt8(instance).HasValue)); + nullableInt8.SetSetter( + (CompiledModelTestBase.ManyTypes entity, sbyte? value) => ManyTypesUnsafeAccessors.NullableInt8(entity) = value); + nullableInt8.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, sbyte? value) => ManyTypesUnsafeAccessors.NullableInt8(entity) = value); + nullableInt8.SetAccessors( + sbyte? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + sbyte? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + sbyte? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableInt8, 177), + sbyte? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableInt8), + object (ValueBuffer valueBuffer) => valueBuffer[177]); + nullableInt8.SetPropertyIndexes( + index: 177, + originalValueIndex: 177, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableInt8.TypeMapping = MySqlSByteTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (sbyte)v1 == (sbyte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(sbyte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(sbyte)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (sbyte)v1 == (sbyte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(sbyte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(sbyte)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (sbyte)v1 == (sbyte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(sbyte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(sbyte)v : default(Nullable))); + comparer: new ValueComparer( + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), + keyComparer: new ValueComparer( + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), + providerValueComparer: new ValueComparer( + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v)); + nullableInt8.SetComparer(new NullableValueComparer(nullableInt8.TypeMapping.Comparer)); + nullableInt8.SetKeyComparer(new NullableValueComparer(nullableInt8.TypeMapping.KeyComparer)); nullableInt8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableInt8Array = runtimeEntityType.AddProperty( @@ -7295,39 +11094,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(sbyte?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableInt8Array.SetGetter( + sbyte? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt8Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableInt8Array(entity) == null, + sbyte? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt8Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableInt8Array(instance) == null); + nullableInt8Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, sbyte? [] value) => ManyTypesUnsafeAccessors.NullableInt8Array(entity) = value); + nullableInt8Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, sbyte? [] value) => ManyTypesUnsafeAccessors.NullableInt8Array(entity) = value); + nullableInt8Array.SetAccessors( + sbyte? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + sbyte? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableInt8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + sbyte? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableInt8Array, 178), + sbyte? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableInt8Array), + object (ValueBuffer valueBuffer) => valueBuffer[178]); + nullableInt8Array.SetPropertyIndexes( + index: 178, + originalValueIndex: 178, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableInt8Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (sbyte)v1 == (sbyte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(sbyte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(sbyte)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (sbyte)v1 == (sbyte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(sbyte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(sbyte)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonSByteReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonSByteReaderWriter.Instance), elementMapping: MySqlSByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), keyComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v), + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v), providerValueComparer: new ValueComparer( - (sbyte v1, sbyte v2) => v1 == v2, - (sbyte v) => (int)v, - (sbyte v) => v))); + bool (sbyte v1, sbyte v2) => v1 == v2, + int (sbyte v) => ((int)(v)), + sbyte (sbyte v) => v))); nullableInt8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullablePhysicalAddress = runtimeEntityType.AddProperty( @@ -7336,30 +11156,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullablePhysicalAddress", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullablePhysicalAddress.SetGetter( + PhysicalAddress (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullablePhysicalAddress(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullablePhysicalAddress(entity) == null, + PhysicalAddress (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullablePhysicalAddress(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullablePhysicalAddress(instance) == null); + nullablePhysicalAddress.SetSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress value) => ManyTypesUnsafeAccessors.NullablePhysicalAddress(entity) = value); + nullablePhysicalAddress.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress value) => ManyTypesUnsafeAccessors.NullablePhysicalAddress(entity) = value); + nullablePhysicalAddress.SetAccessors( + PhysicalAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullablePhysicalAddress(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullablePhysicalAddress(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress (InternalEntityEntry entry) => entry.ReadOriginalValue(nullablePhysicalAddress, 179), + PhysicalAddress (InternalEntityEntry entry) => entry.GetCurrentValue(nullablePhysicalAddress), + object (ValueBuffer valueBuffer) => valueBuffer[179]); + nullablePhysicalAddress.SetPropertyIndexes( + index: 179, + originalValueIndex: 179, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullablePhysicalAddress.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), keyComparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(20)", size: 20), converter: new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)), + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)))); + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)))); nullablePhysicalAddress.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullablePhysicalAddressArray = runtimeEntityType.AddProperty( @@ -7367,58 +11208,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(PhysicalAddress[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullablePhysicalAddressArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullablePhysicalAddressArray.SetGetter( + PhysicalAddress[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullablePhysicalAddressArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullablePhysicalAddressArray(entity) == null, + PhysicalAddress[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullablePhysicalAddressArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullablePhysicalAddressArray(instance) == null); + nullablePhysicalAddressArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress[] value) => ManyTypesUnsafeAccessors.NullablePhysicalAddressArray(entity) = value); + nullablePhysicalAddressArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress[] value) => ManyTypesUnsafeAccessors.NullablePhysicalAddressArray(entity) = value); + nullablePhysicalAddressArray.SetAccessors( + PhysicalAddress[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullablePhysicalAddressArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullablePhysicalAddressArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress[] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullablePhysicalAddressArray, 180), + PhysicalAddress[] (InternalEntityEntry entry) => entry.GetCurrentValue(nullablePhysicalAddressArray), + object (ValueBuffer valueBuffer) => valueBuffer[180]); + nullablePhysicalAddressArray.SetPropertyIndexes( + index: 180, + originalValueIndex: 180, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullablePhysicalAddressArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v))))), + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)))), + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), keyComparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(20)", size: 20), converter: new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)), + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v))))); + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v))))); nullablePhysicalAddressArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableString = runtimeEntityType.AddProperty( @@ -7427,19 +11289,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableString.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableString(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableString(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableString(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableString(instance) == null); + nullableString.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.NullableString(entity) = value); + nullableString.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.NullableString(entity) = value); + nullableString.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableString(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableString, 181), + string (InternalEntityEntry entry) => entry.GetCurrentValue(nullableString), + object (ValueBuffer valueBuffer) => valueBuffer[181]); + nullableString.SetPropertyIndexes( + index: 181, + originalValueIndex: 181, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableString.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None); @@ -7450,39 +11333,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(string[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableStringArray.SetGetter( + string[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableStringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableStringArray(entity) == null, + string[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableStringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableStringArray(instance) == null); + nullableStringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string[] value) => ManyTypesUnsafeAccessors.NullableStringArray(entity) = value); + nullableStringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string[] value) => ManyTypesUnsafeAccessors.NullableStringArray(entity) = value); + nullableStringArray.SetAccessors( + string[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableStringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string[] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableStringArray, 182), + string[] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableStringArray), + object (ValueBuffer valueBuffer) => valueBuffer[182]); + nullableStringArray.SetPropertyIndexes( + index: 182, + originalValueIndex: 182, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableStringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( JsonStringReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( JsonStringReaderWriter.Instance), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None)); @@ -7494,22 +11398,45 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableTimeOnly", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableTimeOnly.SetGetter( + TimeOnly? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableTimeOnly(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableTimeOnly(entity).HasValue), + TimeOnly? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableTimeOnly(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableTimeOnly(instance).HasValue)); + nullableTimeOnly.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly? value) => ManyTypesUnsafeAccessors.NullableTimeOnly(entity) = value); + nullableTimeOnly.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly? value) => ManyTypesUnsafeAccessors.NullableTimeOnly(entity) = value); + nullableTimeOnly.SetAccessors( + TimeOnly? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableTimeOnly(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableTimeOnly(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableTimeOnly, 183), + TimeOnly? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableTimeOnly), + object (ValueBuffer valueBuffer) => valueBuffer[183]); + nullableTimeOnly.SetPropertyIndexes( + index: 183, + originalValueIndex: 183, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableTimeOnly.TypeMapping = MySqlTimeTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeOnly)v1 == (TimeOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeOnly)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeOnly)v1 == (TimeOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeOnly)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeOnly)v1 == (TimeOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeOnly)v : default(Nullable)), + comparer: new ValueComparer( + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), + keyComparer: new ValueComparer( + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), + providerValueComparer: new ValueComparer( + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", precision: 6)); + nullableTimeOnly.SetComparer(new NullableValueComparer(nullableTimeOnly.TypeMapping.Comparer)); + nullableTimeOnly.SetKeyComparer(new NullableValueComparer(nullableTimeOnly.TypeMapping.KeyComparer)); nullableTimeOnly.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableTimeOnlyArray = runtimeEntityType.AddProperty( @@ -7517,39 +11444,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(TimeOnly?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableTimeOnlyArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableTimeOnlyArray.SetGetter( + TimeOnly? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableTimeOnlyArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableTimeOnlyArray(entity) == null, + TimeOnly? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableTimeOnlyArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableTimeOnlyArray(instance) == null); + nullableTimeOnlyArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly? [] value) => ManyTypesUnsafeAccessors.NullableTimeOnlyArray(entity) = value); + nullableTimeOnlyArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly? [] value) => ManyTypesUnsafeAccessors.NullableTimeOnlyArray(entity) = value); + nullableTimeOnlyArray.SetAccessors( + TimeOnly? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableTimeOnlyArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableTimeOnlyArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableTimeOnlyArray, 184), + TimeOnly? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableTimeOnlyArray), + object (ValueBuffer valueBuffer) => valueBuffer[184]); + nullableTimeOnlyArray.SetPropertyIndexes( + index: 184, + originalValueIndex: 184, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableTimeOnlyArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeOnly)v1 == (TimeOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeOnly)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeOnly)v1 == (TimeOnly)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeOnly)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeOnly)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonTimeOnlyReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonTimeOnlyReaderWriter.Instance), elementMapping: MySqlTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), keyComparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), providerValueComparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", precision: 6))); @@ -7561,23 +11509,46 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableTimeSpan", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableTimeSpan.SetGetter( + TimeSpan? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableTimeSpan(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableTimeSpan(entity).HasValue), + TimeSpan? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableTimeSpan(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableTimeSpan(instance).HasValue)); + nullableTimeSpan.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan? value) => ManyTypesUnsafeAccessors.NullableTimeSpan(entity) = value); + nullableTimeSpan.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan? value) => ManyTypesUnsafeAccessors.NullableTimeSpan(entity) = value); + nullableTimeSpan.SetAccessors( + TimeSpan? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableTimeSpan(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableTimeSpan(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableTimeSpan, 185), + TimeSpan? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableTimeSpan), + object (ValueBuffer valueBuffer) => valueBuffer[185]); + nullableTimeSpan.SetPropertyIndexes( + index: 185, + originalValueIndex: 185, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableTimeSpan.TypeMapping = MySqlTimeTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeSpan)v1 == (TimeSpan)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeSpan)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeSpan)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeSpan)v1 == (TimeSpan)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeSpan)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeSpan)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeSpan)v1 == (TimeSpan)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeSpan)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeSpan)v : default(Nullable)), + comparer: new ValueComparer( + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), + keyComparer: new ValueComparer( + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), + providerValueComparer: new ValueComparer( + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", precision: 6), clrType: typeof(TimeSpan)); + nullableTimeSpan.SetComparer(new NullableValueComparer(nullableTimeSpan.TypeMapping.Comparer)); + nullableTimeSpan.SetKeyComparer(new NullableValueComparer(nullableTimeSpan.TypeMapping.KeyComparer)); nullableTimeSpan.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableTimeSpanArray = runtimeEntityType.AddProperty( @@ -7585,41 +11556,62 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(TimeSpan?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableTimeSpanArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableTimeSpanArray.SetGetter( + TimeSpan? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableTimeSpanArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableTimeSpanArray(entity) == null, + TimeSpan? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableTimeSpanArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableTimeSpanArray(instance) == null); + nullableTimeSpanArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan? [] value) => ManyTypesUnsafeAccessors.NullableTimeSpanArray(entity) = value); + nullableTimeSpanArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan? [] value) => ManyTypesUnsafeAccessors.NullableTimeSpanArray(entity) = value); + nullableTimeSpanArray.SetAccessors( + TimeSpan? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableTimeSpanArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableTimeSpanArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableTimeSpanArray, 186), + TimeSpan? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableTimeSpanArray), + object (ValueBuffer valueBuffer) => valueBuffer[186]); + nullableTimeSpanArray.SetPropertyIndexes( + index: 186, + originalValueIndex: 186, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableTimeSpanArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeSpan)v1 == (TimeSpan)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeSpan)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeSpan)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (TimeSpan)v1 == (TimeSpan)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((TimeSpan)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(TimeSpan)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( new JsonCastValueReaderWriter( JsonTimeOnlyReaderWriter.Instance))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( new JsonCastValueReaderWriter( JsonTimeOnlyReaderWriter.Instance)), elementMapping: MySqlTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), keyComparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), providerValueComparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", precision: 6), @@ -7632,19 +11624,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableUInt16.SetGetter( + ushort? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt16(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableUInt16(entity).HasValue), + ushort? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt16(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableUInt16(instance).HasValue)); + nullableUInt16.SetSetter( + (CompiledModelTestBase.ManyTypes entity, ushort? value) => ManyTypesUnsafeAccessors.NullableUInt16(entity) = value); + nullableUInt16.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, ushort? value) => ManyTypesUnsafeAccessors.NullableUInt16(entity) = value); + nullableUInt16.SetAccessors( + ushort? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ushort? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ushort? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUInt16, 187), + ushort? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUInt16), + object (ValueBuffer valueBuffer) => valueBuffer[187]); + nullableUInt16.SetPropertyIndexes( + index: 187, + originalValueIndex: 187, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUInt16.TypeMapping = MySqlUShortTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ushort)v1 == (ushort)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(ushort)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(ushort)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ushort)v1 == (ushort)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(ushort)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(ushort)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ushort)v1 == (ushort)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(ushort)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(ushort)v : default(Nullable))); + comparer: new ValueComparer( + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), + keyComparer: new ValueComparer( + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), + providerValueComparer: new ValueComparer( + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v)); + nullableUInt16.SetComparer(new NullableValueComparer(nullableUInt16.TypeMapping.Comparer)); + nullableUInt16.SetKeyComparer(new NullableValueComparer(nullableUInt16.TypeMapping.KeyComparer)); nullableUInt16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableUInt16Array = runtimeEntityType.AddProperty( @@ -7652,39 +11667,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(ushort?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUInt16Array.SetGetter( + ushort? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt16Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt16Array(entity) == null, + ushort? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt16Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt16Array(instance) == null); + nullableUInt16Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, ushort? [] value) => ManyTypesUnsafeAccessors.NullableUInt16Array(entity) = value); + nullableUInt16Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, ushort? [] value) => ManyTypesUnsafeAccessors.NullableUInt16Array(entity) = value); + nullableUInt16Array.SetAccessors( + ushort? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ushort? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ushort? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUInt16Array, 188), + ushort? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUInt16Array), + object (ValueBuffer valueBuffer) => valueBuffer[188]); + nullableUInt16Array.SetPropertyIndexes( + index: 188, + originalValueIndex: 188, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUInt16Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ushort)v1 == (ushort)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(ushort)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(ushort)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ushort)v1 == (ushort)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(ushort)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(ushort)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonUInt16ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonUInt16ReaderWriter.Instance), elementMapping: MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), keyComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v))); + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v))); nullableUInt16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableUInt32 = runtimeEntityType.AddProperty( @@ -7693,19 +11729,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableUInt32.SetGetter( + uint? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt32(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableUInt32(entity).HasValue), + uint? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt32(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableUInt32(instance).HasValue)); + nullableUInt32.SetSetter( + (CompiledModelTestBase.ManyTypes entity, uint? value) => ManyTypesUnsafeAccessors.NullableUInt32(entity) = value); + nullableUInt32.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, uint? value) => ManyTypesUnsafeAccessors.NullableUInt32(entity) = value); + nullableUInt32.SetAccessors( + uint? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + uint? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + uint? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUInt32, 189), + uint? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUInt32), + object (ValueBuffer valueBuffer) => valueBuffer[189]); + nullableUInt32.SetPropertyIndexes( + index: 189, + originalValueIndex: 189, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUInt32.TypeMapping = MySqlUIntTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (uint)v1 == (uint)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(uint)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(uint)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (uint)v1 == (uint)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(uint)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(uint)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (uint)v1 == (uint)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(uint)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(uint)v : default(Nullable))); + comparer: new ValueComparer( + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), + keyComparer: new ValueComparer( + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), + providerValueComparer: new ValueComparer( + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v)); + nullableUInt32.SetComparer(new NullableValueComparer(nullableUInt32.TypeMapping.Comparer)); + nullableUInt32.SetKeyComparer(new NullableValueComparer(nullableUInt32.TypeMapping.KeyComparer)); nullableUInt32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableUInt32Array = runtimeEntityType.AddProperty( @@ -7713,39 +11772,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(uint?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUInt32Array.SetGetter( + uint? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt32Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt32Array(entity) == null, + uint? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt32Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt32Array(instance) == null); + nullableUInt32Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, uint? [] value) => ManyTypesUnsafeAccessors.NullableUInt32Array(entity) = value); + nullableUInt32Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, uint? [] value) => ManyTypesUnsafeAccessors.NullableUInt32Array(entity) = value); + nullableUInt32Array.SetAccessors( + uint? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + uint? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + uint? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUInt32Array, 190), + uint? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUInt32Array), + object (ValueBuffer valueBuffer) => valueBuffer[190]); + nullableUInt32Array.SetPropertyIndexes( + index: 190, + originalValueIndex: 190, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUInt32Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (uint)v1 == (uint)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(uint)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(uint)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (uint)v1 == (uint)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(uint)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(uint)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonUInt32ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonUInt32ReaderWriter.Instance), elementMapping: MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), keyComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v))); + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v))); nullableUInt32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableUInt64 = runtimeEntityType.AddProperty( @@ -7754,19 +11834,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableUInt64.SetGetter( + ulong? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt64(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableUInt64(entity).HasValue), + ulong? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt64(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableUInt64(instance).HasValue)); + nullableUInt64.SetSetter( + (CompiledModelTestBase.ManyTypes entity, ulong? value) => ManyTypesUnsafeAccessors.NullableUInt64(entity) = value); + nullableUInt64.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, ulong? value) => ManyTypesUnsafeAccessors.NullableUInt64(entity) = value); + nullableUInt64.SetAccessors( + ulong? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ulong? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ulong? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUInt64, 191), + ulong? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUInt64), + object (ValueBuffer valueBuffer) => valueBuffer[191]); + nullableUInt64.SetPropertyIndexes( + index: 191, + originalValueIndex: 191, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUInt64.TypeMapping = MySqlULongTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ulong)v1 == (ulong)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((ulong)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(ulong)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ulong)v1 == (ulong)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((ulong)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(ulong)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ulong)v1 == (ulong)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((ulong)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(ulong)v : default(Nullable))); + comparer: new ValueComparer( + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), + keyComparer: new ValueComparer( + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), + providerValueComparer: new ValueComparer( + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v)); + nullableUInt64.SetComparer(new NullableValueComparer(nullableUInt64.TypeMapping.Comparer)); + nullableUInt64.SetKeyComparer(new NullableValueComparer(nullableUInt64.TypeMapping.KeyComparer)); nullableUInt64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableUInt64Array = runtimeEntityType.AddProperty( @@ -7774,39 +11877,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(ulong?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUInt64Array.SetGetter( + ulong? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt64Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt64Array(entity) == null, + ulong? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt64Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt64Array(instance) == null); + nullableUInt64Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, ulong? [] value) => ManyTypesUnsafeAccessors.NullableUInt64Array(entity) = value); + nullableUInt64Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, ulong? [] value) => ManyTypesUnsafeAccessors.NullableUInt64Array(entity) = value); + nullableUInt64Array.SetAccessors( + ulong? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ulong? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ulong? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUInt64Array, 192), + ulong? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUInt64Array), + object (ValueBuffer valueBuffer) => valueBuffer[192]); + nullableUInt64Array.SetPropertyIndexes( + index: 192, + originalValueIndex: 192, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUInt64Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ulong)v1 == (ulong)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((ulong)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(ulong)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (ulong)v1 == (ulong)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((ulong)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(ulong)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonUInt64ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonUInt64ReaderWriter.Instance), elementMapping: MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), keyComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v))); + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v))); nullableUInt64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableUInt8 = runtimeEntityType.AddProperty( @@ -7815,19 +11939,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableUInt8.SetGetter( + byte? (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt8(entity), + bool (CompiledModelTestBase.ManyTypes entity) => !(ManyTypesUnsafeAccessors.NullableUInt8(entity).HasValue), + byte? (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt8(instance), + bool (CompiledModelTestBase.ManyTypes instance) => !(ManyTypesUnsafeAccessors.NullableUInt8(instance).HasValue)); + nullableUInt8.SetSetter( + (CompiledModelTestBase.ManyTypes entity, byte? value) => ManyTypesUnsafeAccessors.NullableUInt8(entity) = value); + nullableUInt8.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, byte? value) => ManyTypesUnsafeAccessors.NullableUInt8(entity) = value); + nullableUInt8.SetAccessors( + byte? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte? (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte? (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUInt8, 193), + byte? (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUInt8), + object (ValueBuffer valueBuffer) => valueBuffer[193]); + nullableUInt8.SetPropertyIndexes( + index: 193, + originalValueIndex: 193, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUInt8.TypeMapping = MySqlByteTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (byte)v1 == (byte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(byte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(byte)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (byte)v1 == (byte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(byte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(byte)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (byte)v1 == (byte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(byte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(byte)v : default(Nullable))); + comparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + keyComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + providerValueComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)); + nullableUInt8.SetComparer(new NullableValueComparer(nullableUInt8.TypeMapping.Comparer)); + nullableUInt8.SetKeyComparer(new NullableValueComparer(nullableUInt8.TypeMapping.KeyComparer)); nullableUInt8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableUInt8Array = runtimeEntityType.AddProperty( @@ -7835,39 +11982,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(byte?[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUInt8Array.SetGetter( + byte? [] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt8Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUInt8Array(entity) == null, + byte? [] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt8Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUInt8Array(instance) == null); + nullableUInt8Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, byte? [] value) => ManyTypesUnsafeAccessors.NullableUInt8Array(entity) = value); + nullableUInt8Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, byte? [] value) => ManyTypesUnsafeAccessors.NullableUInt8Array(entity) = value); + nullableUInt8Array.SetAccessors( + byte? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte? [] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUInt8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte? [] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUInt8Array, 194), + byte? [] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUInt8Array), + object (ValueBuffer valueBuffer) => valueBuffer[194]); + nullableUInt8Array.SetPropertyIndexes( + index: 194, + originalValueIndex: 194, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUInt8Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (byte)v1 == (byte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(byte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(byte)v : default(Nullable))), - keyComparer: new NullableValueTypeListComparer(new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (byte)v1 == (byte)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? (int)(byte)v : 0, - (Nullable v) => v.HasValue ? (Nullable)(byte)v : default(Nullable))), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))), + keyComparer: new ListOfNullableValueTypesComparer(new NullableValueComparer(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonNullableStructCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfNullableStructsReaderWriter( JsonByteReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonNullableStructCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfNullableStructsReaderWriter( JsonByteReaderWriter.Instance), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), keyComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v))); + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))); nullableUInt8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableUri = runtimeEntityType.AddProperty( @@ -7876,30 +12044,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUri", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + nullableUri.SetGetter( + Uri (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUri(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUri(entity) == null, + Uri (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUri(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUri(instance) == null); + nullableUri.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Uri value) => ManyTypesUnsafeAccessors.NullableUri(entity) = value); + nullableUri.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Uri value) => ManyTypesUnsafeAccessors.NullableUri(entity) = value); + nullableUri.SetAccessors( + Uri (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUri(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUri(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUri, 195), + Uri (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUri), + object (ValueBuffer valueBuffer) => valueBuffer[195]); + nullableUri.SetPropertyIndexes( + index: 195, + originalValueIndex: 195, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUri.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), keyComparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))); + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))); nullableUri.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var nullableUriArray = runtimeEntityType.AddProperty( @@ -7907,58 +12096,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(Uri[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUriArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUriArray.SetGetter( + Uri[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUriArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.NullableUriArray(entity) == null, + Uri[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUriArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.NullableUriArray(instance) == null); + nullableUriArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Uri[] value) => ManyTypesUnsafeAccessors.NullableUriArray(entity) = value); + nullableUriArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Uri[] value) => ManyTypesUnsafeAccessors.NullableUriArray(entity) = value); + nullableUriArray.SetAccessors( + Uri[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUriArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.NullableUriArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri[] (InternalEntityEntry entry) => entry.ReadOriginalValue(nullableUriArray, 196), + Uri[] (InternalEntityEntry entry) => entry.GetCurrentValue(nullableUriArray), + object (ValueBuffer valueBuffer) => valueBuffer[196]); + nullableUriArray.SetPropertyIndexes( + index: 196, + originalValueIndex: 196, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); nullableUriArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute))))), + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))), + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), keyComparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute))))); + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute))))); nullableUriArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var physicalAddress = runtimeEntityType.AddProperty( @@ -7966,30 +12176,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(PhysicalAddress), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("PhysicalAddress", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + physicalAddress.SetGetter( + PhysicalAddress (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.PhysicalAddress(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.PhysicalAddress(entity) == null, + PhysicalAddress (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.PhysicalAddress(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.PhysicalAddress(instance) == null); + physicalAddress.SetSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress value) => ManyTypesUnsafeAccessors.PhysicalAddress(entity) = value); + physicalAddress.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress value) => ManyTypesUnsafeAccessors.PhysicalAddress(entity) = value); + physicalAddress.SetAccessors( + PhysicalAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.PhysicalAddress(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.PhysicalAddress(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress (InternalEntityEntry entry) => entry.ReadOriginalValue(physicalAddress, 197), + PhysicalAddress (InternalEntityEntry entry) => entry.GetCurrentValue(physicalAddress), + object (ValueBuffer valueBuffer) => valueBuffer[197]); + physicalAddress.SetPropertyIndexes( + index: 197, + originalValueIndex: 197, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); physicalAddress.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), keyComparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(20)", size: 20), converter: new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)), + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)))); + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)))); physicalAddress.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var physicalAddressArray = runtimeEntityType.AddProperty( @@ -7997,58 +12228,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(PhysicalAddress[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("PhysicalAddressArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + physicalAddressArray.SetGetter( + PhysicalAddress[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.PhysicalAddressArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.PhysicalAddressArray(entity) == null, + PhysicalAddress[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.PhysicalAddressArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.PhysicalAddressArray(instance) == null); + physicalAddressArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress[] value) => ManyTypesUnsafeAccessors.PhysicalAddressArray(entity) = value); + physicalAddressArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress[] value) => ManyTypesUnsafeAccessors.PhysicalAddressArray(entity) = value); + physicalAddressArray.SetAccessors( + PhysicalAddress[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.PhysicalAddressArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.PhysicalAddressArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress[] (InternalEntityEntry entry) => entry.ReadOriginalValue(physicalAddressArray, 198), + PhysicalAddress[] (InternalEntityEntry entry) => entry.GetCurrentValue(physicalAddressArray), + object (ValueBuffer valueBuffer) => valueBuffer[198]); + physicalAddressArray.SetPropertyIndexes( + index: 198, + originalValueIndex: 198, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); physicalAddressArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v))))), + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)))), + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), keyComparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(20)", size: 20), converter: new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)), + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v))))); + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v))))); physicalAddressArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var physicalAddressToBytesConverterProperty = runtimeEntityType.AddProperty( @@ -8057,31 +12309,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("PhysicalAddressToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new PhysicalAddressToBytesConverter()); + physicalAddressToBytesConverterProperty.SetGetter( + PhysicalAddress (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.PhysicalAddressToBytesConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.PhysicalAddressToBytesConverterProperty(entity) == null, + PhysicalAddress (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.PhysicalAddressToBytesConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.PhysicalAddressToBytesConverterProperty(instance) == null); + physicalAddressToBytesConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress value) => ManyTypesUnsafeAccessors.PhysicalAddressToBytesConverterProperty(entity) = value); + physicalAddressToBytesConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress value) => ManyTypesUnsafeAccessors.PhysicalAddressToBytesConverterProperty(entity) = value); + physicalAddressToBytesConverterProperty.SetAccessors( + PhysicalAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.PhysicalAddressToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.PhysicalAddressToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress (InternalEntityEntry entry) => entry.ReadOriginalValue(physicalAddressToBytesConverterProperty, 199), + PhysicalAddress (InternalEntityEntry entry) => entry.GetCurrentValue(physicalAddressToBytesConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[199]); + physicalAddressToBytesConverterProperty.SetPropertyIndexes( + index: 199, + originalValueIndex: 199, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); physicalAddressToBytesConverterProperty.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), keyComparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varbinary(8)", size: 8), converter: new ValueConverter( - (PhysicalAddress v) => v.GetAddressBytes(), - (Byte[] v) => new PhysicalAddress(v)), + byte[] (PhysicalAddress v) => v.GetAddressBytes(), + PhysicalAddress (byte[] v) => new PhysicalAddress(v)), storeTypePostfix: StoreTypePostfix.Size, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteArrayReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.GetAddressBytes(), - (Byte[] v) => new PhysicalAddress(v)))); + byte[] (PhysicalAddress v) => v.GetAddressBytes(), + PhysicalAddress (byte[] v) => new PhysicalAddress(v)))); physicalAddressToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var physicalAddressToStringConverterProperty = runtimeEntityType.AddProperty( @@ -8090,30 +12363,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("PhysicalAddressToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new PhysicalAddressToStringConverter()); + physicalAddressToStringConverterProperty.SetGetter( + PhysicalAddress (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.PhysicalAddressToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.PhysicalAddressToStringConverterProperty(entity) == null, + PhysicalAddress (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.PhysicalAddressToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.PhysicalAddressToStringConverterProperty(instance) == null); + physicalAddressToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress value) => ManyTypesUnsafeAccessors.PhysicalAddressToStringConverterProperty(entity) = value); + physicalAddressToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, PhysicalAddress value) => ManyTypesUnsafeAccessors.PhysicalAddressToStringConverterProperty(entity) = value); + physicalAddressToStringConverterProperty.SetAccessors( + PhysicalAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.PhysicalAddressToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.PhysicalAddressToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + PhysicalAddress (InternalEntityEntry entry) => entry.ReadOriginalValue(physicalAddressToStringConverterProperty, 200), + PhysicalAddress (InternalEntityEntry entry) => entry.GetCurrentValue(physicalAddressToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[200]); + physicalAddressToStringConverterProperty.SetPropertyIndexes( + index: 200, + originalValueIndex: 200, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); physicalAddressToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), keyComparer: new ValueComparer( - (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), - (PhysicalAddress v) => v.GetHashCode(), - (PhysicalAddress v) => v), + bool (PhysicalAddress v1, PhysicalAddress v2) => object.Equals(v1, v2), + int (PhysicalAddress v) => ((object)v).GetHashCode(), + PhysicalAddress (PhysicalAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(20)", size: 20), converter: new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)), + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (PhysicalAddress v) => v.ToString(), - (string v) => PhysicalAddress.Parse(v)))); + string (PhysicalAddress v) => ((object)v).ToString(), + PhysicalAddress (string v) => PhysicalAddress.Parse(v)))); physicalAddressToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var @string = runtimeEntityType.AddProperty( @@ -8121,19 +12415,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(string), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("String", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + @string.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.String(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.String(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.String(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.String(instance) == null); + @string.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.String(entity) = value); + @string.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.String(entity) = value); + @string.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.String(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.String(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(@string, 201), + string (InternalEntityEntry entry) => entry.GetCurrentValue(@string), + object (ValueBuffer valueBuffer) => valueBuffer[201]); + @string.SetPropertyIndexes( + index: 201, + originalValueIndex: 201, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); @string.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None); @@ -8144,39 +12459,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(string[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + stringArray.SetGetter( + string[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringArray(entity) == null, + string[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringArray(instance) == null); + stringArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string[] value) => ManyTypesUnsafeAccessors.StringArray(entity) = value); + stringArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string[] value) => ManyTypesUnsafeAccessors.StringArray(entity) = value); + stringArray.SetAccessors( + string[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string[] (InternalEntityEntry entry) => entry.ReadOriginalValue(stringArray, 202), + string[] (InternalEntityEntry entry) => entry.GetCurrentValue(stringArray), + object (ValueBuffer valueBuffer) => valueBuffer[202]); + stringArray.SetPropertyIndexes( + index: 202, + originalValueIndex: 202, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( JsonStringReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( JsonStringReaderWriter.Instance), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None)); @@ -8188,27 +12524,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToBoolConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToBoolConverter()); + stringToBoolConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToBoolConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToBoolConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToBoolConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToBoolConverterProperty(instance) == null); + stringToBoolConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToBoolConverterProperty(entity) = value); + stringToBoolConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToBoolConverterProperty(entity) = value); + stringToBoolConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToBoolConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToBoolConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToBoolConverterProperty, 203), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToBoolConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[203]); + stringToBoolConverterProperty.SetPropertyIndexes( + index: 203, + originalValueIndex: 203, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToBoolConverterProperty.TypeMapping = MySqlBoolTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), converter: new ValueConverter( - (string v) => Convert.ToBoolean(v), - (bool v) => Convert.ToString(v)), + bool (string v) => Convert.ToBoolean(v), + string (bool v) => Convert.ToString(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonBoolReaderWriter.Instance, new ValueConverter( - (string v) => Convert.ToBoolean(v), - (bool v) => Convert.ToString(v)))); + bool (string v) => Convert.ToBoolean(v), + string (bool v) => Convert.ToString(v)))); stringToBoolConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToBytesConverterProperty = runtimeEntityType.AddProperty( @@ -8217,27 +12574,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + stringToBytesConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToBytesConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToBytesConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToBytesConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToBytesConverterProperty(instance) == null); + stringToBytesConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToBytesConverterProperty(entity) = value); + stringToBytesConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToBytesConverterProperty(entity) = value); + stringToBytesConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToBytesConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToBytesConverterProperty, 204), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToBytesConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[204]); + stringToBytesConverterProperty.SetPropertyIndexes( + index: 204, + originalValueIndex: 204, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToBytesConverterProperty.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), converter: new ValueConverter( - (string v) => Encoding.UTF32.GetBytes(v), - (Byte[] v) => Encoding.UTF32.GetString(v)), + byte[] (string v) => Encoding.GetEncoding(12000).GetBytes(v), + string (byte[] v) => Encoding.GetEncoding(12000).GetString(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonByteArrayReaderWriter.Instance, new ValueConverter( - (string v) => Encoding.UTF32.GetBytes(v), - (Byte[] v) => Encoding.UTF32.GetString(v)))); + byte[] (string v) => Encoding.GetEncoding(12000).GetBytes(v), + string (byte[] v) => Encoding.GetEncoding(12000).GetString(v)))); stringToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToCharConverterProperty = runtimeEntityType.AddProperty( @@ -8246,30 +12624,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToCharConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToCharConverter()); + stringToCharConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToCharConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToCharConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToCharConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToCharConverterProperty(instance) == null); + stringToCharConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToCharConverterProperty(entity) = value); + stringToCharConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToCharConverterProperty(entity) = value); + stringToCharConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToCharConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToCharConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToCharConverterProperty, 205), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToCharConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[205]); + stringToCharConverterProperty.SetPropertyIndexes( + index: 205, + originalValueIndex: 205, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToCharConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(1)", size: 1), converter: new ValueConverter( - (string v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)(v.Length < 1 ? '\0' : v[0])), - (string v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)(v.Length < 1 ? '\0' : v[0]))), + string (string v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)((v.Length < 1 ? '\0' : v[0])))), + string (string v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)((v.Length < 1 ? '\0' : v[0]))))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (string v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)(v.Length < 1 ? '\0' : v[0])), - (string v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)(v.Length < 1 ? '\0' : v[0]))))); + string (string v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)((v.Length < 1 ? '\0' : v[0])))), + string (string v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)((v.Length < 1 ? '\0' : v[0]))))))); stringToCharConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToDateOnlyConverterProperty = runtimeEntityType.AddProperty( @@ -8278,29 +12677,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDateOnlyConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToDateOnlyConverter()); + stringToDateOnlyConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDateOnlyConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDateOnlyConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDateOnlyConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDateOnlyConverterProperty(instance) == null); + stringToDateOnlyConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDateOnlyConverterProperty(entity) = value); + stringToDateOnlyConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDateOnlyConverterProperty(entity) = value); + stringToDateOnlyConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDateOnlyConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDateOnlyConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToDateOnlyConverterProperty, 206), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToDateOnlyConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[206]); + stringToDateOnlyConverterProperty.SetPropertyIndexes( + index: 206, + originalValueIndex: 206, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToDateOnlyConverterProperty.TypeMapping = MySqlDateTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (DateOnly v1, DateOnly v2) => v1.Equals(v2), - (DateOnly v) => v.GetHashCode(), - (DateOnly v) => v), + bool (DateOnly v1, DateOnly v2) => v1.Equals(v2), + int (DateOnly v) => ((object)v).GetHashCode(), + DateOnly (DateOnly v) => v), mappingInfo: new RelationalTypeMappingInfo( size: 10), converter: new ValueConverter( - (string v) => DateOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None), - (DateOnly v) => v.ToString("yyyy\\-MM\\-dd")), + DateOnly (string v) => DateOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None), + string (DateOnly v) => v.ToString("yyyy\\-MM\\-dd")), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonDateOnlyReaderWriter.Instance, new ValueConverter( - (string v) => DateOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None), - (DateOnly v) => v.ToString("yyyy\\-MM\\-dd")))); + DateOnly (string v) => DateOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None), + string (DateOnly v) => v.ToString("yyyy\\-MM\\-dd")))); stringToDateOnlyConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToDateTimeConverterProperty = runtimeEntityType.AddProperty( @@ -8309,31 +12729,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDateTimeConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToDateTimeConverter()); + stringToDateTimeConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDateTimeConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDateTimeConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDateTimeConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDateTimeConverterProperty(instance) == null); + stringToDateTimeConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDateTimeConverterProperty(entity) = value); + stringToDateTimeConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDateTimeConverterProperty(entity) = value); + stringToDateTimeConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDateTimeConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDateTimeConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToDateTimeConverterProperty, 207), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToDateTimeConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[207]); + stringToDateTimeConverterProperty.SetPropertyIndexes( + index: 207, + originalValueIndex: 207, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToDateTimeConverterProperty.TypeMapping = MySqlDateTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", size: 48, precision: 6), converter: new ValueConverter( - (string v) => DateTime.Parse(v, CultureInfo.InvariantCulture), - (DateTime v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFF")), + DateTime (string v) => DateTime.Parse(v, CultureInfo.InvariantCulture), + string (DateTime v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFF")), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonDateTimeReaderWriter.Instance, new ValueConverter( - (string v) => DateTime.Parse(v, CultureInfo.InvariantCulture), - (DateTime v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFF")))); + DateTime (string v) => DateTime.Parse(v, CultureInfo.InvariantCulture), + string (DateTime v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFF")))); stringToDateTimeConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToDateTimeOffsetConverterProperty = runtimeEntityType.AddProperty( @@ -8342,31 +12783,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDateTimeOffsetConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToDateTimeOffsetConverter()); + stringToDateTimeOffsetConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDateTimeOffsetConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDateTimeOffsetConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDateTimeOffsetConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDateTimeOffsetConverterProperty(instance) == null); + stringToDateTimeOffsetConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDateTimeOffsetConverterProperty(entity) = value); + stringToDateTimeOffsetConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDateTimeOffsetConverterProperty(entity) = value); + stringToDateTimeOffsetConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDateTimeOffsetConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDateTimeOffsetConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToDateTimeOffsetConverterProperty, 208), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToDateTimeOffsetConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[208]); + stringToDateTimeOffsetConverterProperty.SetPropertyIndexes( + index: 208, + originalValueIndex: 208, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToDateTimeOffsetConverterProperty.TypeMapping = MySqlDateTimeOffsetTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), - (DateTimeOffset v) => v.GetHashCode(), - (DateTimeOffset v) => v), + bool (DateTimeOffset v1, DateTimeOffset v2) => v1.EqualsExact(v2), + int (DateTimeOffset v) => ((object)v).GetHashCode(), + DateTimeOffset (DateTimeOffset v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", size: 48, precision: 6), converter: new ValueConverter( - (string v) => DateTimeOffset.Parse(v, CultureInfo.InvariantCulture), - (DateTimeOffset v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFFzzz")), + DateTimeOffset (string v) => DateTimeOffset.Parse(v, CultureInfo.InvariantCulture), + string (DateTimeOffset v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFFzzz")), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonDateTimeOffsetReaderWriter.Instance, new ValueConverter( - (string v) => DateTimeOffset.Parse(v, CultureInfo.InvariantCulture), - (DateTimeOffset v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFFzzz")))); + DateTimeOffset (string v) => DateTimeOffset.Parse(v, CultureInfo.InvariantCulture), + string (DateTimeOffset v) => v.ToString("yyyy\\-MM\\-dd HH\\:mm\\:ss.FFFFFFFzzz")))); stringToDateTimeOffsetConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToDecimalNumberConverterProperty = runtimeEntityType.AddProperty( @@ -8375,29 +12837,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDecimalNumberConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToNumberConverter()); + stringToDecimalNumberConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDecimalNumberConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDecimalNumberConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDecimalNumberConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDecimalNumberConverterProperty(instance) == null); + stringToDecimalNumberConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDecimalNumberConverterProperty(entity) = value); + stringToDecimalNumberConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDecimalNumberConverterProperty(entity) = value); + stringToDecimalNumberConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDecimalNumberConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDecimalNumberConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToDecimalNumberConverterProperty, 209), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToDecimalNumberConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[209]); + stringToDecimalNumberConverterProperty.SetPropertyIndexes( + index: 209, + originalValueIndex: 209, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToDecimalNumberConverterProperty.TypeMapping = MySqlDecimalTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (decimal v1, decimal v2) => v1 == v2, - (decimal v) => v.GetHashCode(), - (decimal v) => v), + bool (decimal v1, decimal v2) => v1 == v2, + int (decimal v) => ((object)v).GetHashCode(), + decimal (decimal v) => v), mappingInfo: new RelationalTypeMappingInfo( size: 64), converter: new ValueConverter( - (string v) => decimal.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), - (decimal v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v)), + decimal (string v) => decimal.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), + string (decimal v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v)))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonDecimalReaderWriter.Instance, new ValueConverter( - (string v) => decimal.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), - (decimal v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v)))); + decimal (string v) => decimal.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), + string (decimal v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v)))))); stringToDecimalNumberConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToDoubleNumberConverterProperty = runtimeEntityType.AddProperty( @@ -8406,29 +12889,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDoubleNumberConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToNumberConverter()); + stringToDoubleNumberConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDoubleNumberConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToDoubleNumberConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDoubleNumberConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToDoubleNumberConverterProperty(instance) == null); + stringToDoubleNumberConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDoubleNumberConverterProperty(entity) = value); + stringToDoubleNumberConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToDoubleNumberConverterProperty(entity) = value); + stringToDoubleNumberConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDoubleNumberConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToDoubleNumberConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToDoubleNumberConverterProperty, 210), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToDoubleNumberConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[210]); + stringToDoubleNumberConverterProperty.SetPropertyIndexes( + index: 210, + originalValueIndex: 210, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToDoubleNumberConverterProperty.TypeMapping = MySqlDoubleTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (double v1, double v2) => v1.Equals(v2), - (double v) => v.GetHashCode(), - (double v) => v), + bool (double v1, double v2) => v1.Equals(v2), + int (double v) => ((object)v).GetHashCode(), + double (double v) => v), mappingInfo: new RelationalTypeMappingInfo( size: 64), converter: new ValueConverter( - (string v) => double.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), - (double v) => string.Format(CultureInfo.InvariantCulture, "{0:R}", (object)v)), + double (string v) => double.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), + string (double v) => string.Format(CultureInfo.InvariantCulture, "{0:R}", ((object)(v)))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonDoubleReaderWriter.Instance, new ValueConverter( - (string v) => double.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), - (double v) => string.Format(CultureInfo.InvariantCulture, "{0:R}", (object)v)))); + double (string v) => double.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), + string (double v) => string.Format(CultureInfo.InvariantCulture, "{0:R}", ((object)(v)))))); stringToDoubleNumberConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToEnumConverterProperty = runtimeEntityType.AddProperty( @@ -8437,27 +12941,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToEnumConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToEnumConverter()); + stringToEnumConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToEnumConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToEnumConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToEnumConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToEnumConverterProperty(instance) == null); + stringToEnumConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToEnumConverterProperty(entity) = value); + stringToEnumConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToEnumConverterProperty(entity) = value); + stringToEnumConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToEnumConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToEnumConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToEnumConverterProperty, 211), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToEnumConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[211]); + stringToEnumConverterProperty.SetPropertyIndexes( + index: 211, + originalValueIndex: 211, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToEnumConverterProperty.TypeMapping = MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), converter: new ValueConverter( - (string v) => (uint)StringEnumConverter.ConvertToEnum(v), - (uint value) => ((CompiledModelTestBase.EnumU32)value).ToString()), + uint (string v) => ((uint)(StringEnumConverter.ConvertToEnum(v))), + string (uint value) => ((object)((CompiledModelTestBase.EnumU32)(value))).ToString()), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonUInt32ReaderWriter.Instance, new ValueConverter( - (string v) => (uint)StringEnumConverter.ConvertToEnum(v), - (uint value) => ((CompiledModelTestBase.EnumU32)value).ToString()))); + uint (string v) => ((uint)(StringEnumConverter.ConvertToEnum(v))), + string (uint value) => ((object)((CompiledModelTestBase.EnumU32)(value))).ToString()))); stringToEnumConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToGuidConverterProperty = runtimeEntityType.AddProperty( @@ -8465,19 +12990,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(string), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToGuidConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + stringToGuidConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToGuidConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToGuidConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToGuidConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToGuidConverterProperty(instance) == null); + stringToGuidConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToGuidConverterProperty(entity) = value); + stringToGuidConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToGuidConverterProperty(entity) = value); + stringToGuidConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToGuidConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToGuidConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToGuidConverterProperty, 212), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToGuidConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[212]); + stringToGuidConverterProperty.SetPropertyIndexes( + index: 212, + originalValueIndex: 212, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToGuidConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None); @@ -8489,29 +13035,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToIntNumberConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToNumberConverter()); + stringToIntNumberConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToIntNumberConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToIntNumberConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToIntNumberConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToIntNumberConverterProperty(instance) == null); + stringToIntNumberConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToIntNumberConverterProperty(entity) = value); + stringToIntNumberConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToIntNumberConverterProperty(entity) = value); + stringToIntNumberConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToIntNumberConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToIntNumberConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToIntNumberConverterProperty, 213), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToIntNumberConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[213]); + stringToIntNumberConverterProperty.SetPropertyIndexes( + index: 213, + originalValueIndex: 213, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToIntNumberConverterProperty.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), mappingInfo: new RelationalTypeMappingInfo( size: 64), converter: new ValueConverter( - (string v) => int.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), - (int v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v)), + int (string v) => int.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), + string (int v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v)))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (string v) => int.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), - (int v) => string.Format(CultureInfo.InvariantCulture, "{0}", (object)v)))); + int (string v) => int.Parse(v, NumberStyles.Any, CultureInfo.InvariantCulture), + string (int v) => string.Format(CultureInfo.InvariantCulture, "{0}", ((object)(v)))))); stringToIntNumberConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToTimeOnlyConverterProperty = runtimeEntityType.AddProperty( @@ -8520,31 +13087,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToTimeOnlyConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToTimeOnlyConverter()); + stringToTimeOnlyConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToTimeOnlyConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToTimeOnlyConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToTimeOnlyConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToTimeOnlyConverterProperty(instance) == null); + stringToTimeOnlyConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToTimeOnlyConverterProperty(entity) = value); + stringToTimeOnlyConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToTimeOnlyConverterProperty(entity) = value); + stringToTimeOnlyConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToTimeOnlyConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToTimeOnlyConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToTimeOnlyConverterProperty, 214), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToTimeOnlyConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[214]); + stringToTimeOnlyConverterProperty.SetPropertyIndexes( + index: 214, + originalValueIndex: 214, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToTimeOnlyConverterProperty.TypeMapping = MySqlTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", size: 48, precision: 6), converter: new ValueConverter( - (string v) => TimeOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None), - (TimeOnly v) => v.Ticks % 10000000L == 0L ? string.Format(CultureInfo.InvariantCulture, "{0:HH\\:mm\\:ss}", (object)v) : v.ToString("o")), + TimeOnly (string v) => TimeOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None), + string (TimeOnly v) => (v.Ticks % 10000000L == 0L ? string.Format(CultureInfo.InvariantCulture, "{0:HH\\:mm\\:ss}", ((object)(v))) : v.ToString("o"))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonTimeOnlyReaderWriter.Instance, new ValueConverter( - (string v) => TimeOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None), - (TimeOnly v) => v.Ticks % 10000000L == 0L ? string.Format(CultureInfo.InvariantCulture, "{0:HH\\:mm\\:ss}", (object)v) : v.ToString("o")))); + TimeOnly (string v) => TimeOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None), + string (TimeOnly v) => (v.Ticks % 10000000L == 0L ? string.Format(CultureInfo.InvariantCulture, "{0:HH\\:mm\\:ss}", ((object)(v))) : v.ToString("o"))))); stringToTimeOnlyConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToTimeSpanConverterProperty = runtimeEntityType.AddProperty( @@ -8553,31 +13141,52 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToTimeSpanConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToTimeSpanConverter()); + stringToTimeSpanConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToTimeSpanConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToTimeSpanConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToTimeSpanConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToTimeSpanConverterProperty(instance) == null); + stringToTimeSpanConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToTimeSpanConverterProperty(entity) = value); + stringToTimeSpanConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToTimeSpanConverterProperty(entity) = value); + stringToTimeSpanConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToTimeSpanConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToTimeSpanConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToTimeSpanConverterProperty, 215), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToTimeSpanConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[215]); + stringToTimeSpanConverterProperty.SetPropertyIndexes( + index: 215, + originalValueIndex: 215, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToTimeSpanConverterProperty.TypeMapping = MySqlTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", size: 48, precision: 6), converter: new ValueConverter( - (string v) => TimeSpan.Parse(v, CultureInfo.InvariantCulture), - (TimeSpan v) => v.ToString("c")), + TimeSpan (string v) => TimeSpan.Parse(v, CultureInfo.InvariantCulture), + string (TimeSpan v) => v.ToString("c")), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonTimeOnlyReaderWriter.Instance, new ValueConverter( - (string v) => TimeSpan.Parse(v, CultureInfo.InvariantCulture), - (TimeSpan v) => v.ToString("c")))); + TimeSpan (string v) => TimeSpan.Parse(v, CultureInfo.InvariantCulture), + string (TimeSpan v) => v.ToString("c")))); stringToTimeSpanConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringToUriConverterProperty = runtimeEntityType.AddProperty( @@ -8586,30 +13195,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToUriConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new StringToUriConverter()); + stringToUriConverterProperty.SetGetter( + string (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToUriConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.StringToUriConverterProperty(entity) == null, + string (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToUriConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.StringToUriConverterProperty(instance) == null); + stringToUriConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToUriConverterProperty(entity) = value); + stringToUriConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, string value) => ManyTypesUnsafeAccessors.StringToUriConverterProperty(entity) = value); + stringToUriConverterProperty.SetAccessors( + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToUriConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.StringToUriConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringToUriConverterProperty, 216), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringToUriConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[216]); + stringToUriConverterProperty.SetPropertyIndexes( + index: 216, + originalValueIndex: 216, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); stringToUriConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (string v) => new Uri(v, UriKind.RelativeOrAbsolute).ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute).ToString()), + string (string v) => ((object)new Uri(v, UriKind.RelativeOrAbsolute)).ToString(), + string (string v) => ((object)new Uri(v, UriKind.RelativeOrAbsolute)).ToString()), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (string v) => new Uri(v, UriKind.RelativeOrAbsolute).ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute).ToString()))); + string (string v) => ((object)new Uri(v, UriKind.RelativeOrAbsolute)).ToString(), + string (string v) => ((object)new Uri(v, UriKind.RelativeOrAbsolute)).ToString()))); stringToUriConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var timeOnly = runtimeEntityType.AddProperty( @@ -8618,19 +13248,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeOnly", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: new TimeOnly(0, 0, 0)); + timeOnly.SetGetter( + TimeOnly (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeOnly(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeOnly(entity) == default(TimeOnly), + TimeOnly (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeOnly(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeOnly(instance) == default(TimeOnly)); + timeOnly.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly value) => ManyTypesUnsafeAccessors.TimeOnly(entity) = value); + timeOnly.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly value) => ManyTypesUnsafeAccessors.TimeOnly(entity) = value); + timeOnly.SetAccessors( + TimeOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeOnly(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeOnly(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly (InternalEntityEntry entry) => entry.ReadOriginalValue(timeOnly, 217), + TimeOnly (InternalEntityEntry entry) => entry.GetCurrentValue(timeOnly), + object (ValueBuffer valueBuffer) => valueBuffer[217]); + timeOnly.SetPropertyIndexes( + index: 217, + originalValueIndex: 217, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); timeOnly.TypeMapping = MySqlTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), keyComparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), providerValueComparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", precision: 6)); @@ -8641,39 +13292,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(TimeOnly[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeOnlyArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + timeOnlyArray.SetGetter( + TimeOnly[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeOnlyArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeOnlyArray(entity) == null, + TimeOnly[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeOnlyArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeOnlyArray(instance) == null); + timeOnlyArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly[] value) => ManyTypesUnsafeAccessors.TimeOnlyArray(entity) = value); + timeOnlyArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly[] value) => ManyTypesUnsafeAccessors.TimeOnlyArray(entity) = value); + timeOnlyArray.SetAccessors( + TimeOnly[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeOnlyArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeOnlyArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly[] (InternalEntityEntry entry) => entry.ReadOriginalValue(timeOnlyArray, 218), + TimeOnly[] (InternalEntityEntry entry) => entry.GetCurrentValue(timeOnlyArray), + object (ValueBuffer valueBuffer) => valueBuffer[218]); + timeOnlyArray.SetPropertyIndexes( + index: 218, + originalValueIndex: 218, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); timeOnlyArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonTimeOnlyReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonTimeOnlyReaderWriter.Instance), elementMapping: MySqlTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), keyComparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), providerValueComparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", precision: 6))); @@ -8685,30 +13357,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeOnlyToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new TimeOnlyToStringConverter()); + timeOnlyToStringConverterProperty.SetGetter( + TimeOnly (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeOnlyToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeOnlyToStringConverterProperty(entity) == default(TimeOnly), + TimeOnly (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeOnlyToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeOnlyToStringConverterProperty(instance) == default(TimeOnly)); + timeOnlyToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly value) => ManyTypesUnsafeAccessors.TimeOnlyToStringConverterProperty(entity) = value); + timeOnlyToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly value) => ManyTypesUnsafeAccessors.TimeOnlyToStringConverterProperty(entity) = value); + timeOnlyToStringConverterProperty.SetAccessors( + TimeOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeOnlyToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeOnlyToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly (InternalEntityEntry entry) => entry.ReadOriginalValue(timeOnlyToStringConverterProperty, 219), + TimeOnly (InternalEntityEntry entry) => entry.GetCurrentValue(timeOnlyToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[219]); + timeOnlyToStringConverterProperty.SetPropertyIndexes( + index: 219, + originalValueIndex: 219, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); timeOnlyToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), keyComparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(48)", size: 48), converter: new ValueConverter( - (TimeOnly v) => v.Ticks % 10000000L == 0L ? string.Format(CultureInfo.InvariantCulture, "{0:HH\\:mm\\:ss}", (object)v) : v.ToString("o"), - (string v) => TimeOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None)), + string (TimeOnly v) => (v.Ticks % 10000000L == 0L ? string.Format(CultureInfo.InvariantCulture, "{0:HH\\:mm\\:ss}", ((object)(v))) : v.ToString("o")), + TimeOnly (string v) => TimeOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (TimeOnly v) => v.Ticks % 10000000L == 0L ? string.Format(CultureInfo.InvariantCulture, "{0:HH\\:mm\\:ss}", (object)v) : v.ToString("o"), - (string v) => TimeOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None)))); + string (TimeOnly v) => (v.Ticks % 10000000L == 0L ? string.Format(CultureInfo.InvariantCulture, "{0:HH\\:mm\\:ss}", ((object)(v))) : v.ToString("o")), + TimeOnly (string v) => TimeOnly.Parse(v, CultureInfo.InvariantCulture, DateTimeStyles.None)))); timeOnlyToStringConverterProperty.SetSentinelFromProviderValue("00:00:00"); timeOnlyToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -8718,27 +13411,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeOnlyToTicksConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new TimeOnlyToTicksConverter()); + timeOnlyToTicksConverterProperty.SetGetter( + TimeOnly (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeOnlyToTicksConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeOnlyToTicksConverterProperty(entity) == default(TimeOnly), + TimeOnly (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeOnlyToTicksConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeOnlyToTicksConverterProperty(instance) == default(TimeOnly)); + timeOnlyToTicksConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly value) => ManyTypesUnsafeAccessors.TimeOnlyToTicksConverterProperty(entity) = value); + timeOnlyToTicksConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeOnly value) => ManyTypesUnsafeAccessors.TimeOnlyToTicksConverterProperty(entity) = value); + timeOnlyToTicksConverterProperty.SetAccessors( + TimeOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeOnlyToTicksConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeOnlyToTicksConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeOnly (InternalEntityEntry entry) => entry.ReadOriginalValue(timeOnlyToTicksConverterProperty, 220), + TimeOnly (InternalEntityEntry entry) => entry.GetCurrentValue(timeOnlyToTicksConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[220]); + timeOnlyToTicksConverterProperty.SetPropertyIndexes( + index: 220, + originalValueIndex: 220, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); timeOnlyToTicksConverterProperty.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), keyComparer: new ValueComparer( - (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), - (TimeOnly v) => v.GetHashCode(), - (TimeOnly v) => v), + bool (TimeOnly v1, TimeOnly v2) => v1.Equals(v2), + int (TimeOnly v) => ((object)v).GetHashCode(), + TimeOnly (TimeOnly v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (TimeOnly v) => v.Ticks, - (long v) => new TimeOnly(v)), + long (TimeOnly v) => v.Ticks, + TimeOnly (long v) => new TimeOnly(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (TimeOnly v) => v.Ticks, - (long v) => new TimeOnly(v)))); + long (TimeOnly v) => v.Ticks, + TimeOnly (long v) => new TimeOnly(v)))); timeOnlyToTicksConverterProperty.SetSentinelFromProviderValue(0L); timeOnlyToTicksConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -8748,19 +13462,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeSpan", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: new TimeSpan(0, 0, 0, 0, 0)); + timeSpan.SetGetter( + TimeSpan (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeSpan(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeSpan(entity) == default(TimeSpan), + TimeSpan (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeSpan(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeSpan(instance) == default(TimeSpan)); + timeSpan.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan value) => ManyTypesUnsafeAccessors.TimeSpan(entity) = value); + timeSpan.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan value) => ManyTypesUnsafeAccessors.TimeSpan(entity) = value); + timeSpan.SetAccessors( + TimeSpan (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeSpan(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeSpan(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan (InternalEntityEntry entry) => entry.ReadOriginalValue(timeSpan, 221), + TimeSpan (InternalEntityEntry entry) => entry.GetCurrentValue(timeSpan), + object (ValueBuffer valueBuffer) => valueBuffer[221]); + timeSpan.SetPropertyIndexes( + index: 221, + originalValueIndex: 221, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); timeSpan.TypeMapping = MySqlTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), keyComparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), providerValueComparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", precision: 6), @@ -8772,41 +13507,62 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(TimeSpan[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeSpanArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + timeSpanArray.SetGetter( + TimeSpan[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeSpanArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeSpanArray(entity) == null, + TimeSpan[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeSpanArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeSpanArray(instance) == null); + timeSpanArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan[] value) => ManyTypesUnsafeAccessors.TimeSpanArray(entity) = value); + timeSpanArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan[] value) => ManyTypesUnsafeAccessors.TimeSpanArray(entity) = value); + timeSpanArray.SetAccessors( + TimeSpan[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeSpanArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeSpanArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan[] (InternalEntityEntry entry) => entry.ReadOriginalValue(timeSpanArray, 222), + TimeSpan[] (InternalEntityEntry entry) => entry.GetCurrentValue(timeSpanArray), + object (ValueBuffer valueBuffer) => valueBuffer[222]); + timeSpanArray.SetPropertyIndexes( + index: 222, + originalValueIndex: 222, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); timeSpanArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( new JsonCastValueReaderWriter( JsonTimeOnlyReaderWriter.Instance))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( new JsonCastValueReaderWriter( JsonTimeOnlyReaderWriter.Instance)), elementMapping: MySqlTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), keyComparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), providerValueComparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "time(6)", precision: 6), @@ -8819,30 +13575,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeSpanToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new TimeSpanToStringConverter()); + timeSpanToStringConverterProperty.SetGetter( + TimeSpan (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeSpanToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeSpanToStringConverterProperty(entity) == default(TimeSpan), + TimeSpan (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeSpanToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeSpanToStringConverterProperty(instance) == default(TimeSpan)); + timeSpanToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan value) => ManyTypesUnsafeAccessors.TimeSpanToStringConverterProperty(entity) = value); + timeSpanToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan value) => ManyTypesUnsafeAccessors.TimeSpanToStringConverterProperty(entity) = value); + timeSpanToStringConverterProperty.SetAccessors( + TimeSpan (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeSpanToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeSpanToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan (InternalEntityEntry entry) => entry.ReadOriginalValue(timeSpanToStringConverterProperty, 223), + TimeSpan (InternalEntityEntry entry) => entry.GetCurrentValue(timeSpanToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[223]); + timeSpanToStringConverterProperty.SetPropertyIndexes( + index: 223, + originalValueIndex: 223, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); timeSpanToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), keyComparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(48)", size: 48), converter: new ValueConverter( - (TimeSpan v) => v.ToString("c"), - (string v) => TimeSpan.Parse(v, CultureInfo.InvariantCulture)), + string (TimeSpan v) => v.ToString("c"), + TimeSpan (string v) => TimeSpan.Parse(v, CultureInfo.InvariantCulture)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (TimeSpan v) => v.ToString("c"), - (string v) => TimeSpan.Parse(v, CultureInfo.InvariantCulture)))); + string (TimeSpan v) => v.ToString("c"), + TimeSpan (string v) => TimeSpan.Parse(v, CultureInfo.InvariantCulture)))); timeSpanToStringConverterProperty.SetSentinelFromProviderValue("00:00:00"); timeSpanToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -8852,27 +13629,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeSpanToTicksConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new TimeSpanToTicksConverter()); + timeSpanToTicksConverterProperty.SetGetter( + TimeSpan (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeSpanToTicksConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.TimeSpanToTicksConverterProperty(entity) == default(TimeSpan), + TimeSpan (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeSpanToTicksConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.TimeSpanToTicksConverterProperty(instance) == default(TimeSpan)); + timeSpanToTicksConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan value) => ManyTypesUnsafeAccessors.TimeSpanToTicksConverterProperty(entity) = value); + timeSpanToTicksConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, TimeSpan value) => ManyTypesUnsafeAccessors.TimeSpanToTicksConverterProperty(entity) = value); + timeSpanToTicksConverterProperty.SetAccessors( + TimeSpan (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeSpanToTicksConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.TimeSpanToTicksConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + TimeSpan (InternalEntityEntry entry) => entry.ReadOriginalValue(timeSpanToTicksConverterProperty, 224), + TimeSpan (InternalEntityEntry entry) => entry.GetCurrentValue(timeSpanToTicksConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[224]); + timeSpanToTicksConverterProperty.SetPropertyIndexes( + index: 224, + originalValueIndex: 224, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); timeSpanToTicksConverterProperty.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), keyComparer: new ValueComparer( - (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), - (TimeSpan v) => v.GetHashCode(), - (TimeSpan v) => v), + bool (TimeSpan v1, TimeSpan v2) => v1.Equals(v2), + int (TimeSpan v) => ((object)v).GetHashCode(), + TimeSpan (TimeSpan v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), converter: new ValueConverter( - (TimeSpan v) => v.Ticks, - (long v) => new TimeSpan(v)), + long (TimeSpan v) => v.Ticks, + TimeSpan (long v) => new TimeSpan(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt64ReaderWriter.Instance, new ValueConverter( - (TimeSpan v) => v.Ticks, - (long v) => new TimeSpan(v)))); + long (TimeSpan v) => v.Ticks, + TimeSpan (long v) => new TimeSpan(v)))); timeSpanToTicksConverterProperty.SetSentinelFromProviderValue(0L); timeSpanToTicksConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -8882,19 +13680,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: (ushort)0); + uInt16.SetGetter( + ushort (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt16(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt16(entity) == 0, + ushort (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt16(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt16(instance) == 0); + uInt16.SetSetter( + (CompiledModelTestBase.ManyTypes entity, ushort value) => ManyTypesUnsafeAccessors.UInt16(entity) = value); + uInt16.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, ushort value) => ManyTypesUnsafeAccessors.UInt16(entity) = value); + uInt16.SetAccessors( + ushort (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ushort (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt16(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ushort (InternalEntityEntry entry) => entry.ReadOriginalValue(uInt16, 225), + ushort (InternalEntityEntry entry) => entry.GetCurrentValue(uInt16), + object (ValueBuffer valueBuffer) => valueBuffer[225]); + uInt16.SetPropertyIndexes( + index: 225, + originalValueIndex: 225, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uInt16.TypeMapping = MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), keyComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v)); + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v)); uInt16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uInt16Array = runtimeEntityType.AddProperty( @@ -8902,39 +13721,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(ushort[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uInt16Array.SetGetter( + ushort[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt16Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt16Array(entity) == null, + ushort[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt16Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt16Array(instance) == null); + uInt16Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, ushort[] value) => ManyTypesUnsafeAccessors.UInt16Array(entity) = value); + uInt16Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, ushort[] value) => ManyTypesUnsafeAccessors.UInt16Array(entity) = value); + uInt16Array.SetAccessors( + ushort[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ushort[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt16Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ushort[] (InternalEntityEntry entry) => entry.ReadOriginalValue(uInt16Array, 226), + ushort[] (InternalEntityEntry entry) => entry.GetCurrentValue(uInt16Array), + object (ValueBuffer valueBuffer) => valueBuffer[226]); + uInt16Array.SetPropertyIndexes( + index: 226, + originalValueIndex: 226, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uInt16Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonUInt16ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonUInt16ReaderWriter.Instance), elementMapping: MySqlUShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), keyComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v), + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v), providerValueComparer: new ValueComparer( - (ushort v1, ushort v2) => v1 == v2, - (ushort v) => (int)v, - (ushort v) => v))); + bool (ushort v1, ushort v2) => v1 == v2, + int (ushort v) => ((int)(v)), + ushort (ushort v) => v))); uInt16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uInt32 = runtimeEntityType.AddProperty( @@ -8943,19 +13783,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: 0u); + uInt32.SetGetter( + uint (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt32(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt32(entity) == 0U, + uint (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt32(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt32(instance) == 0U); + uInt32.SetSetter( + (CompiledModelTestBase.ManyTypes entity, uint value) => ManyTypesUnsafeAccessors.UInt32(entity) = value); + uInt32.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, uint value) => ManyTypesUnsafeAccessors.UInt32(entity) = value); + uInt32.SetAccessors( + uint (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + uint (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt32(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + uint (InternalEntityEntry entry) => entry.ReadOriginalValue(uInt32, 227), + uint (InternalEntityEntry entry) => entry.GetCurrentValue(uInt32), + object (ValueBuffer valueBuffer) => valueBuffer[227]); + uInt32.SetPropertyIndexes( + index: 227, + originalValueIndex: 227, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uInt32.TypeMapping = MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), keyComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v)); + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v)); uInt32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uInt32Array = runtimeEntityType.AddProperty( @@ -8963,39 +13824,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(uint[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uInt32Array.SetGetter( + uint[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt32Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt32Array(entity) == null, + uint[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt32Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt32Array(instance) == null); + uInt32Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, uint[] value) => ManyTypesUnsafeAccessors.UInt32Array(entity) = value); + uInt32Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, uint[] value) => ManyTypesUnsafeAccessors.UInt32Array(entity) = value); + uInt32Array.SetAccessors( + uint[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + uint[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt32Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + uint[] (InternalEntityEntry entry) => entry.ReadOriginalValue(uInt32Array, 228), + uint[] (InternalEntityEntry entry) => entry.GetCurrentValue(uInt32Array), + object (ValueBuffer valueBuffer) => valueBuffer[228]); + uInt32Array.SetPropertyIndexes( + index: 228, + originalValueIndex: 228, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uInt32Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonUInt32ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonUInt32ReaderWriter.Instance), elementMapping: MySqlUIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), keyComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v), + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v), providerValueComparer: new ValueComparer( - (uint v1, uint v2) => v1 == v2, - (uint v) => (int)v, - (uint v) => v))); + bool (uint v1, uint v2) => v1 == v2, + int (uint v) => ((int)(v)), + uint (uint v) => v))); uInt32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uInt64 = runtimeEntityType.AddProperty( @@ -9004,19 +13886,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: 0ul); + uInt64.SetGetter( + ulong (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt64(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt64(entity) == 0UL, + ulong (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt64(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt64(instance) == 0UL); + uInt64.SetSetter( + (CompiledModelTestBase.ManyTypes entity, ulong value) => ManyTypesUnsafeAccessors.UInt64(entity) = value); + uInt64.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, ulong value) => ManyTypesUnsafeAccessors.UInt64(entity) = value); + uInt64.SetAccessors( + ulong (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ulong (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt64(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ulong (InternalEntityEntry entry) => entry.ReadOriginalValue(uInt64, 229), + ulong (InternalEntityEntry entry) => entry.GetCurrentValue(uInt64), + object (ValueBuffer valueBuffer) => valueBuffer[229]); + uInt64.SetPropertyIndexes( + index: 229, + originalValueIndex: 229, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uInt64.TypeMapping = MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), keyComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v)); + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v)); uInt64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uInt64Array = runtimeEntityType.AddProperty( @@ -9024,39 +13927,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(ulong[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uInt64Array.SetGetter( + ulong[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt64Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt64Array(entity) == null, + ulong[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt64Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt64Array(instance) == null); + uInt64Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, ulong[] value) => ManyTypesUnsafeAccessors.UInt64Array(entity) = value); + uInt64Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, ulong[] value) => ManyTypesUnsafeAccessors.UInt64Array(entity) = value); + uInt64Array.SetAccessors( + ulong[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ulong[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt64Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + ulong[] (InternalEntityEntry entry) => entry.ReadOriginalValue(uInt64Array, 230), + ulong[] (InternalEntityEntry entry) => entry.GetCurrentValue(uInt64Array), + object (ValueBuffer valueBuffer) => valueBuffer[230]); + uInt64Array.SetPropertyIndexes( + index: 230, + originalValueIndex: 230, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uInt64Array.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonUInt64ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonUInt64ReaderWriter.Instance), elementMapping: MySqlULongTypeMapping.Default.Clone( comparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), keyComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v), + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v), providerValueComparer: new ValueComparer( - (ulong v1, ulong v2) => v1 == v2, - (ulong v) => v.GetHashCode(), - (ulong v) => v))); + bool (ulong v1, ulong v2) => v1 == v2, + int (ulong v) => ((object)v).GetHashCode(), + ulong (ulong v) => v))); uInt64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uInt8 = runtimeEntityType.AddProperty( @@ -9065,19 +13989,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: (byte)0); + uInt8.SetGetter( + byte (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt8(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt8(entity) == 0, + byte (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt8(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt8(instance) == 0); + uInt8.SetSetter( + (CompiledModelTestBase.ManyTypes entity, byte value) => ManyTypesUnsafeAccessors.UInt8(entity) = value); + uInt8.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, byte value) => ManyTypesUnsafeAccessors.UInt8(entity) = value); + uInt8.SetAccessors( + byte (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt8(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte (InternalEntityEntry entry) => entry.ReadOriginalValue(uInt8, 231), + byte (InternalEntityEntry entry) => entry.GetCurrentValue(uInt8), + object (ValueBuffer valueBuffer) => valueBuffer[231]); + uInt8.SetPropertyIndexes( + index: 231, + originalValueIndex: 231, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uInt8.TypeMapping = MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), keyComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)); + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)); uInt8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uInt8Array = runtimeEntityType.AddProperty( @@ -9085,19 +14030,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(byte[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uInt8Array.SetGetter( + byte[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt8Array(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UInt8Array(entity) == null, + byte[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt8Array(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UInt8Array(instance) == null); + uInt8Array.SetSetter( + (CompiledModelTestBase.ManyTypes entity, byte[] value) => ManyTypesUnsafeAccessors.UInt8Array(entity) = value); + uInt8Array.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, byte[] value) => ManyTypesUnsafeAccessors.UInt8Array(entity) = value); + uInt8Array.SetAccessors( + byte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UInt8Array(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(uInt8Array, 232), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(uInt8Array), + object (ValueBuffer valueBuffer) => valueBuffer[232]); + uInt8Array.SetPropertyIndexes( + index: 232, + originalValueIndex: 232, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uInt8Array.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray())); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray())); uInt8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uri = runtimeEntityType.AddProperty( @@ -9105,30 +14071,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(Uri), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Uri", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uri.SetGetter( + Uri (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Uri(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.Uri(entity) == null, + Uri (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Uri(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.Uri(instance) == null); + uri.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Uri value) => ManyTypesUnsafeAccessors.Uri(entity) = value); + uri.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Uri value) => ManyTypesUnsafeAccessors.Uri(entity) = value); + uri.SetAccessors( + Uri (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Uri(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.Uri(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri (InternalEntityEntry entry) => entry.ReadOriginalValue(uri, 233), + Uri (InternalEntityEntry entry) => entry.GetCurrentValue(uri), + object (ValueBuffer valueBuffer) => valueBuffer[233]); + uri.SetPropertyIndexes( + index: 233, + originalValueIndex: 233, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uri.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), keyComparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))); + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))); uri.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uriArray = runtimeEntityType.AddProperty( @@ -9136,58 +14123,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(Uri[]), propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UriArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uriArray.SetGetter( + Uri[] (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UriArray(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UriArray(entity) == null, + Uri[] (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UriArray(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UriArray(instance) == null); + uriArray.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Uri[] value) => ManyTypesUnsafeAccessors.UriArray(entity) = value); + uriArray.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Uri[] value) => ManyTypesUnsafeAccessors.UriArray(entity) = value); + uriArray.SetAccessors( + Uri[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UriArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri[] (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UriArray(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri[] (InternalEntityEntry entry) => entry.ReadOriginalValue(uriArray, 234), + Uri[] (InternalEntityEntry entry) => entry.GetCurrentValue(uriArray), + object (ValueBuffer valueBuffer) => valueBuffer[234]); + uriArray.SetPropertyIndexes( + index: 234, + originalValueIndex: 234, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uriArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v)), - providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute))))), + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))), + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), keyComparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute))))); + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute))))); uriArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var uriToStringConverterProperty = runtimeEntityType.AddProperty( @@ -9196,30 +14204,51 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UriToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), valueConverter: new UriToStringConverter()); + uriToStringConverterProperty.SetGetter( + Uri (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UriToStringConverterProperty(entity), + bool (CompiledModelTestBase.ManyTypes entity) => ManyTypesUnsafeAccessors.UriToStringConverterProperty(entity) == null, + Uri (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UriToStringConverterProperty(instance), + bool (CompiledModelTestBase.ManyTypes instance) => ManyTypesUnsafeAccessors.UriToStringConverterProperty(instance) == null); + uriToStringConverterProperty.SetSetter( + (CompiledModelTestBase.ManyTypes entity, Uri value) => ManyTypesUnsafeAccessors.UriToStringConverterProperty(entity) = value); + uriToStringConverterProperty.SetMaterializationSetter( + (CompiledModelTestBase.ManyTypes entity, Uri value) => ManyTypesUnsafeAccessors.UriToStringConverterProperty(entity) = value); + uriToStringConverterProperty.SetAccessors( + Uri (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UriToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri (InternalEntityEntry entry) => ManyTypesUnsafeAccessors.UriToStringConverterProperty(((CompiledModelTestBase.ManyTypes)(entry.Entity))), + Uri (InternalEntityEntry entry) => entry.ReadOriginalValue(uriToStringConverterProperty, 235), + Uri (InternalEntityEntry entry) => entry.GetCurrentValue(uriToStringConverterProperty), + object (ValueBuffer valueBuffer) => valueBuffer[235]); + uriToStringConverterProperty.SetPropertyIndexes( + index: 235, + originalValueIndex: 235, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); uriToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), keyComparer: new ValueComparer( - (Uri v1, Uri v2) => v1 == v2, - (Uri v) => v.GetHashCode(), - (Uri v) => v), + bool (Uri v1, Uri v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (Uri v) => ((object)v).GetHashCode(), + Uri (Uri v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), converter: new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)), storeTypePostfix: StoreTypePostfix.None, jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (Uri v) => v.ToString(), - (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))); + string (Uri v) => ((object)v).ToString(), + Uri (string v) => new Uri(v, UriKind.RelativeOrAbsolute)))); uriToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var key = runtimeEntityType.AddKey( @@ -9231,6 +14260,287 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var id = runtimeEntityType.FindProperty("Id"); + var @bool = runtimeEntityType.FindProperty("Bool"); + var boolArray = runtimeEntityType.FindProperty("BoolArray"); + var boolToStringConverterProperty = runtimeEntityType.FindProperty("BoolToStringConverterProperty"); + var boolToTwoValuesConverterProperty = runtimeEntityType.FindProperty("BoolToTwoValuesConverterProperty"); + var boolToZeroOneConverterProperty = runtimeEntityType.FindProperty("BoolToZeroOneConverterProperty"); + var bytes = runtimeEntityType.FindProperty("Bytes"); + var bytesArray = runtimeEntityType.FindProperty("BytesArray"); + var bytesToStringConverterProperty = runtimeEntityType.FindProperty("BytesToStringConverterProperty"); + var castingConverterProperty = runtimeEntityType.FindProperty("CastingConverterProperty"); + var @char = runtimeEntityType.FindProperty("Char"); + var charArray = runtimeEntityType.FindProperty("CharArray"); + var charToStringConverterProperty = runtimeEntityType.FindProperty("CharToStringConverterProperty"); + var dateOnly = runtimeEntityType.FindProperty("DateOnly"); + var dateOnlyArray = runtimeEntityType.FindProperty("DateOnlyArray"); + var dateOnlyToStringConverterProperty = runtimeEntityType.FindProperty("DateOnlyToStringConverterProperty"); + var dateTime = runtimeEntityType.FindProperty("DateTime"); + var dateTimeArray = runtimeEntityType.FindProperty("DateTimeArray"); + var dateTimeOffsetToBinaryConverterProperty = runtimeEntityType.FindProperty("DateTimeOffsetToBinaryConverterProperty"); + var dateTimeOffsetToBytesConverterProperty = runtimeEntityType.FindProperty("DateTimeOffsetToBytesConverterProperty"); + var dateTimeOffsetToStringConverterProperty = runtimeEntityType.FindProperty("DateTimeOffsetToStringConverterProperty"); + var dateTimeToBinaryConverterProperty = runtimeEntityType.FindProperty("DateTimeToBinaryConverterProperty"); + var dateTimeToStringConverterProperty = runtimeEntityType.FindProperty("DateTimeToStringConverterProperty"); + var dateTimeToTicksConverterProperty = runtimeEntityType.FindProperty("DateTimeToTicksConverterProperty"); + var @decimal = runtimeEntityType.FindProperty("Decimal"); + var decimalArray = runtimeEntityType.FindProperty("DecimalArray"); + var decimalNumberToBytesConverterProperty = runtimeEntityType.FindProperty("DecimalNumberToBytesConverterProperty"); + var decimalNumberToStringConverterProperty = runtimeEntityType.FindProperty("DecimalNumberToStringConverterProperty"); + var @double = runtimeEntityType.FindProperty("Double"); + var doubleArray = runtimeEntityType.FindProperty("DoubleArray"); + var doubleNumberToBytesConverterProperty = runtimeEntityType.FindProperty("DoubleNumberToBytesConverterProperty"); + var doubleNumberToStringConverterProperty = runtimeEntityType.FindProperty("DoubleNumberToStringConverterProperty"); + var enum16 = runtimeEntityType.FindProperty("Enum16"); + var enum16Array = runtimeEntityType.FindProperty("Enum16Array"); + var enum16AsString = runtimeEntityType.FindProperty("Enum16AsString"); + var enum16AsStringArray = runtimeEntityType.FindProperty("Enum16AsStringArray"); + var enum16AsStringCollection = runtimeEntityType.FindProperty("Enum16AsStringCollection"); + var enum16Collection = runtimeEntityType.FindProperty("Enum16Collection"); + var enum32 = runtimeEntityType.FindProperty("Enum32"); + var enum32Array = runtimeEntityType.FindProperty("Enum32Array"); + var enum32AsString = runtimeEntityType.FindProperty("Enum32AsString"); + var enum32AsStringArray = runtimeEntityType.FindProperty("Enum32AsStringArray"); + var enum32AsStringCollection = runtimeEntityType.FindProperty("Enum32AsStringCollection"); + var enum32Collection = runtimeEntityType.FindProperty("Enum32Collection"); + var enum64 = runtimeEntityType.FindProperty("Enum64"); + var enum64Array = runtimeEntityType.FindProperty("Enum64Array"); + var enum64AsString = runtimeEntityType.FindProperty("Enum64AsString"); + var enum64AsStringArray = runtimeEntityType.FindProperty("Enum64AsStringArray"); + var enum64AsStringCollection = runtimeEntityType.FindProperty("Enum64AsStringCollection"); + var enum64Collection = runtimeEntityType.FindProperty("Enum64Collection"); + var enum8 = runtimeEntityType.FindProperty("Enum8"); + var enum8Array = runtimeEntityType.FindProperty("Enum8Array"); + var enum8AsString = runtimeEntityType.FindProperty("Enum8AsString"); + var enum8AsStringArray = runtimeEntityType.FindProperty("Enum8AsStringArray"); + var enum8AsStringCollection = runtimeEntityType.FindProperty("Enum8AsStringCollection"); + var enum8Collection = runtimeEntityType.FindProperty("Enum8Collection"); + var enumToNumberConverterProperty = runtimeEntityType.FindProperty("EnumToNumberConverterProperty"); + var enumToStringConverterProperty = runtimeEntityType.FindProperty("EnumToStringConverterProperty"); + var enumU16 = runtimeEntityType.FindProperty("EnumU16"); + var enumU16Array = runtimeEntityType.FindProperty("EnumU16Array"); + var enumU16AsString = runtimeEntityType.FindProperty("EnumU16AsString"); + var enumU16AsStringArray = runtimeEntityType.FindProperty("EnumU16AsStringArray"); + var enumU16AsStringCollection = runtimeEntityType.FindProperty("EnumU16AsStringCollection"); + var enumU16Collection = runtimeEntityType.FindProperty("EnumU16Collection"); + var enumU32 = runtimeEntityType.FindProperty("EnumU32"); + var enumU32Array = runtimeEntityType.FindProperty("EnumU32Array"); + var enumU32AsString = runtimeEntityType.FindProperty("EnumU32AsString"); + var enumU32AsStringArray = runtimeEntityType.FindProperty("EnumU32AsStringArray"); + var enumU32AsStringCollection = runtimeEntityType.FindProperty("EnumU32AsStringCollection"); + var enumU32Collection = runtimeEntityType.FindProperty("EnumU32Collection"); + var enumU64 = runtimeEntityType.FindProperty("EnumU64"); + var enumU64Array = runtimeEntityType.FindProperty("EnumU64Array"); + var enumU64AsString = runtimeEntityType.FindProperty("EnumU64AsString"); + var enumU64AsStringArray = runtimeEntityType.FindProperty("EnumU64AsStringArray"); + var enumU64AsStringCollection = runtimeEntityType.FindProperty("EnumU64AsStringCollection"); + var enumU64Collection = runtimeEntityType.FindProperty("EnumU64Collection"); + var enumU8 = runtimeEntityType.FindProperty("EnumU8"); + var enumU8Array = runtimeEntityType.FindProperty("EnumU8Array"); + var enumU8AsString = runtimeEntityType.FindProperty("EnumU8AsString"); + var enumU8AsStringArray = runtimeEntityType.FindProperty("EnumU8AsStringArray"); + var enumU8AsStringCollection = runtimeEntityType.FindProperty("EnumU8AsStringCollection"); + var enumU8Collection = runtimeEntityType.FindProperty("EnumU8Collection"); + var @float = runtimeEntityType.FindProperty("Float"); + var floatArray = runtimeEntityType.FindProperty("FloatArray"); + var guid = runtimeEntityType.FindProperty("Guid"); + var guidArray = runtimeEntityType.FindProperty("GuidArray"); + var guidToBytesConverterProperty = runtimeEntityType.FindProperty("GuidToBytesConverterProperty"); + var guidToStringConverterProperty = runtimeEntityType.FindProperty("GuidToStringConverterProperty"); + var iPAddress = runtimeEntityType.FindProperty("IPAddress"); + var iPAddressArray = runtimeEntityType.FindProperty("IPAddressArray"); + var iPAddressToBytesConverterProperty = runtimeEntityType.FindProperty("IPAddressToBytesConverterProperty"); + var iPAddressToStringConverterProperty = runtimeEntityType.FindProperty("IPAddressToStringConverterProperty"); + var int16 = runtimeEntityType.FindProperty("Int16"); + var int16Array = runtimeEntityType.FindProperty("Int16Array"); + var int32 = runtimeEntityType.FindProperty("Int32"); + var int32Array = runtimeEntityType.FindProperty("Int32Array"); + var int64 = runtimeEntityType.FindProperty("Int64"); + var int64Array = runtimeEntityType.FindProperty("Int64Array"); + var int8 = runtimeEntityType.FindProperty("Int8"); + var int8Array = runtimeEntityType.FindProperty("Int8Array"); + var intNumberToBytesConverterProperty = runtimeEntityType.FindProperty("IntNumberToBytesConverterProperty"); + var intNumberToStringConverterProperty = runtimeEntityType.FindProperty("IntNumberToStringConverterProperty"); + var nullIntToNullStringConverterProperty = runtimeEntityType.FindProperty("NullIntToNullStringConverterProperty"); + var nullableBool = runtimeEntityType.FindProperty("NullableBool"); + var nullableBoolArray = runtimeEntityType.FindProperty("NullableBoolArray"); + var nullableBytes = runtimeEntityType.FindProperty("NullableBytes"); + var nullableBytesArray = runtimeEntityType.FindProperty("NullableBytesArray"); + var nullableChar = runtimeEntityType.FindProperty("NullableChar"); + var nullableCharArray = runtimeEntityType.FindProperty("NullableCharArray"); + var nullableDateOnly = runtimeEntityType.FindProperty("NullableDateOnly"); + var nullableDateOnlyArray = runtimeEntityType.FindProperty("NullableDateOnlyArray"); + var nullableDateTime = runtimeEntityType.FindProperty("NullableDateTime"); + var nullableDateTimeArray = runtimeEntityType.FindProperty("NullableDateTimeArray"); + var nullableDecimal = runtimeEntityType.FindProperty("NullableDecimal"); + var nullableDecimalArray = runtimeEntityType.FindProperty("NullableDecimalArray"); + var nullableDouble = runtimeEntityType.FindProperty("NullableDouble"); + var nullableDoubleArray = runtimeEntityType.FindProperty("NullableDoubleArray"); + var nullableEnum16 = runtimeEntityType.FindProperty("NullableEnum16"); + var nullableEnum16Array = runtimeEntityType.FindProperty("NullableEnum16Array"); + var nullableEnum16AsString = runtimeEntityType.FindProperty("NullableEnum16AsString"); + var nullableEnum16AsStringArray = runtimeEntityType.FindProperty("NullableEnum16AsStringArray"); + var nullableEnum16AsStringCollection = runtimeEntityType.FindProperty("NullableEnum16AsStringCollection"); + var nullableEnum16Collection = runtimeEntityType.FindProperty("NullableEnum16Collection"); + var nullableEnum32 = runtimeEntityType.FindProperty("NullableEnum32"); + var nullableEnum32Array = runtimeEntityType.FindProperty("NullableEnum32Array"); + var nullableEnum32AsString = runtimeEntityType.FindProperty("NullableEnum32AsString"); + var nullableEnum32AsStringArray = runtimeEntityType.FindProperty("NullableEnum32AsStringArray"); + var nullableEnum32AsStringCollection = runtimeEntityType.FindProperty("NullableEnum32AsStringCollection"); + var nullableEnum32Collection = runtimeEntityType.FindProperty("NullableEnum32Collection"); + var nullableEnum64 = runtimeEntityType.FindProperty("NullableEnum64"); + var nullableEnum64Array = runtimeEntityType.FindProperty("NullableEnum64Array"); + var nullableEnum64AsString = runtimeEntityType.FindProperty("NullableEnum64AsString"); + var nullableEnum64AsStringArray = runtimeEntityType.FindProperty("NullableEnum64AsStringArray"); + var nullableEnum64AsStringCollection = runtimeEntityType.FindProperty("NullableEnum64AsStringCollection"); + var nullableEnum64Collection = runtimeEntityType.FindProperty("NullableEnum64Collection"); + var nullableEnum8 = runtimeEntityType.FindProperty("NullableEnum8"); + var nullableEnum8Array = runtimeEntityType.FindProperty("NullableEnum8Array"); + var nullableEnum8AsString = runtimeEntityType.FindProperty("NullableEnum8AsString"); + var nullableEnum8AsStringArray = runtimeEntityType.FindProperty("NullableEnum8AsStringArray"); + var nullableEnum8AsStringCollection = runtimeEntityType.FindProperty("NullableEnum8AsStringCollection"); + var nullableEnum8Collection = runtimeEntityType.FindProperty("NullableEnum8Collection"); + var nullableEnumU16 = runtimeEntityType.FindProperty("NullableEnumU16"); + var nullableEnumU16Array = runtimeEntityType.FindProperty("NullableEnumU16Array"); + var nullableEnumU16AsString = runtimeEntityType.FindProperty("NullableEnumU16AsString"); + var nullableEnumU16AsStringArray = runtimeEntityType.FindProperty("NullableEnumU16AsStringArray"); + var nullableEnumU16AsStringCollection = runtimeEntityType.FindProperty("NullableEnumU16AsStringCollection"); + var nullableEnumU16Collection = runtimeEntityType.FindProperty("NullableEnumU16Collection"); + var nullableEnumU32 = runtimeEntityType.FindProperty("NullableEnumU32"); + var nullableEnumU32Array = runtimeEntityType.FindProperty("NullableEnumU32Array"); + var nullableEnumU32AsString = runtimeEntityType.FindProperty("NullableEnumU32AsString"); + var nullableEnumU32AsStringArray = runtimeEntityType.FindProperty("NullableEnumU32AsStringArray"); + var nullableEnumU32AsStringCollection = runtimeEntityType.FindProperty("NullableEnumU32AsStringCollection"); + var nullableEnumU32Collection = runtimeEntityType.FindProperty("NullableEnumU32Collection"); + var nullableEnumU64 = runtimeEntityType.FindProperty("NullableEnumU64"); + var nullableEnumU64Array = runtimeEntityType.FindProperty("NullableEnumU64Array"); + var nullableEnumU64AsString = runtimeEntityType.FindProperty("NullableEnumU64AsString"); + var nullableEnumU64AsStringArray = runtimeEntityType.FindProperty("NullableEnumU64AsStringArray"); + var nullableEnumU64AsStringCollection = runtimeEntityType.FindProperty("NullableEnumU64AsStringCollection"); + var nullableEnumU64Collection = runtimeEntityType.FindProperty("NullableEnumU64Collection"); + var nullableEnumU8 = runtimeEntityType.FindProperty("NullableEnumU8"); + var nullableEnumU8Array = runtimeEntityType.FindProperty("NullableEnumU8Array"); + var nullableEnumU8AsString = runtimeEntityType.FindProperty("NullableEnumU8AsString"); + var nullableEnumU8AsStringArray = runtimeEntityType.FindProperty("NullableEnumU8AsStringArray"); + var nullableEnumU8AsStringCollection = runtimeEntityType.FindProperty("NullableEnumU8AsStringCollection"); + var nullableEnumU8Collection = runtimeEntityType.FindProperty("NullableEnumU8Collection"); + var nullableFloat = runtimeEntityType.FindProperty("NullableFloat"); + var nullableFloatArray = runtimeEntityType.FindProperty("NullableFloatArray"); + var nullableGuid = runtimeEntityType.FindProperty("NullableGuid"); + var nullableGuidArray = runtimeEntityType.FindProperty("NullableGuidArray"); + var nullableIPAddress = runtimeEntityType.FindProperty("NullableIPAddress"); + var nullableIPAddressArray = runtimeEntityType.FindProperty("NullableIPAddressArray"); + var nullableInt16 = runtimeEntityType.FindProperty("NullableInt16"); + var nullableInt16Array = runtimeEntityType.FindProperty("NullableInt16Array"); + var nullableInt32 = runtimeEntityType.FindProperty("NullableInt32"); + var nullableInt32Array = runtimeEntityType.FindProperty("NullableInt32Array"); + var nullableInt64 = runtimeEntityType.FindProperty("NullableInt64"); + var nullableInt64Array = runtimeEntityType.FindProperty("NullableInt64Array"); + var nullableInt8 = runtimeEntityType.FindProperty("NullableInt8"); + var nullableInt8Array = runtimeEntityType.FindProperty("NullableInt8Array"); + var nullablePhysicalAddress = runtimeEntityType.FindProperty("NullablePhysicalAddress"); + var nullablePhysicalAddressArray = runtimeEntityType.FindProperty("NullablePhysicalAddressArray"); + var nullableString = runtimeEntityType.FindProperty("NullableString"); + var nullableStringArray = runtimeEntityType.FindProperty("NullableStringArray"); + var nullableTimeOnly = runtimeEntityType.FindProperty("NullableTimeOnly"); + var nullableTimeOnlyArray = runtimeEntityType.FindProperty("NullableTimeOnlyArray"); + var nullableTimeSpan = runtimeEntityType.FindProperty("NullableTimeSpan"); + var nullableTimeSpanArray = runtimeEntityType.FindProperty("NullableTimeSpanArray"); + var nullableUInt16 = runtimeEntityType.FindProperty("NullableUInt16"); + var nullableUInt16Array = runtimeEntityType.FindProperty("NullableUInt16Array"); + var nullableUInt32 = runtimeEntityType.FindProperty("NullableUInt32"); + var nullableUInt32Array = runtimeEntityType.FindProperty("NullableUInt32Array"); + var nullableUInt64 = runtimeEntityType.FindProperty("NullableUInt64"); + var nullableUInt64Array = runtimeEntityType.FindProperty("NullableUInt64Array"); + var nullableUInt8 = runtimeEntityType.FindProperty("NullableUInt8"); + var nullableUInt8Array = runtimeEntityType.FindProperty("NullableUInt8Array"); + var nullableUri = runtimeEntityType.FindProperty("NullableUri"); + var nullableUriArray = runtimeEntityType.FindProperty("NullableUriArray"); + var physicalAddress = runtimeEntityType.FindProperty("PhysicalAddress"); + var physicalAddressArray = runtimeEntityType.FindProperty("PhysicalAddressArray"); + var physicalAddressToBytesConverterProperty = runtimeEntityType.FindProperty("PhysicalAddressToBytesConverterProperty"); + var physicalAddressToStringConverterProperty = runtimeEntityType.FindProperty("PhysicalAddressToStringConverterProperty"); + var @string = runtimeEntityType.FindProperty("String"); + var stringArray = runtimeEntityType.FindProperty("StringArray"); + var stringToBoolConverterProperty = runtimeEntityType.FindProperty("StringToBoolConverterProperty"); + var stringToBytesConverterProperty = runtimeEntityType.FindProperty("StringToBytesConverterProperty"); + var stringToCharConverterProperty = runtimeEntityType.FindProperty("StringToCharConverterProperty"); + var stringToDateOnlyConverterProperty = runtimeEntityType.FindProperty("StringToDateOnlyConverterProperty"); + var stringToDateTimeConverterProperty = runtimeEntityType.FindProperty("StringToDateTimeConverterProperty"); + var stringToDateTimeOffsetConverterProperty = runtimeEntityType.FindProperty("StringToDateTimeOffsetConverterProperty"); + var stringToDecimalNumberConverterProperty = runtimeEntityType.FindProperty("StringToDecimalNumberConverterProperty"); + var stringToDoubleNumberConverterProperty = runtimeEntityType.FindProperty("StringToDoubleNumberConverterProperty"); + var stringToEnumConverterProperty = runtimeEntityType.FindProperty("StringToEnumConverterProperty"); + var stringToGuidConverterProperty = runtimeEntityType.FindProperty("StringToGuidConverterProperty"); + var stringToIntNumberConverterProperty = runtimeEntityType.FindProperty("StringToIntNumberConverterProperty"); + var stringToTimeOnlyConverterProperty = runtimeEntityType.FindProperty("StringToTimeOnlyConverterProperty"); + var stringToTimeSpanConverterProperty = runtimeEntityType.FindProperty("StringToTimeSpanConverterProperty"); + var stringToUriConverterProperty = runtimeEntityType.FindProperty("StringToUriConverterProperty"); + var timeOnly = runtimeEntityType.FindProperty("TimeOnly"); + var timeOnlyArray = runtimeEntityType.FindProperty("TimeOnlyArray"); + var timeOnlyToStringConverterProperty = runtimeEntityType.FindProperty("TimeOnlyToStringConverterProperty"); + var timeOnlyToTicksConverterProperty = runtimeEntityType.FindProperty("TimeOnlyToTicksConverterProperty"); + var timeSpan = runtimeEntityType.FindProperty("TimeSpan"); + var timeSpanArray = runtimeEntityType.FindProperty("TimeSpanArray"); + var timeSpanToStringConverterProperty = runtimeEntityType.FindProperty("TimeSpanToStringConverterProperty"); + var timeSpanToTicksConverterProperty = runtimeEntityType.FindProperty("TimeSpanToTicksConverterProperty"); + var uInt16 = runtimeEntityType.FindProperty("UInt16"); + var uInt16Array = runtimeEntityType.FindProperty("UInt16Array"); + var uInt32 = runtimeEntityType.FindProperty("UInt32"); + var uInt32Array = runtimeEntityType.FindProperty("UInt32Array"); + var uInt64 = runtimeEntityType.FindProperty("UInt64"); + var uInt64Array = runtimeEntityType.FindProperty("UInt64Array"); + var uInt8 = runtimeEntityType.FindProperty("UInt8"); + var uInt8Array = runtimeEntityType.FindProperty("UInt8Array"); + var uri = runtimeEntityType.FindProperty("Uri"); + var uriArray = runtimeEntityType.FindProperty("UriArray"); + var uriToStringConverterProperty = runtimeEntityType.FindProperty("UriToStringConverterProperty"); + var key = runtimeEntityType.FindKey(new[] { id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateSimpleNonNullableFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory(key)); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.ManyTypes)(source.Entity)); + var liftedArg = ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id)), ((ValueComparer)(((IProperty)@bool).GetValueComparer())).Snapshot(source.GetCurrentValue(@bool)), (((IEnumerable)(source.GetCurrentValue(boolArray))) == null ? null : ((bool[])(((ValueComparer>)(((IProperty)boolArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(boolArray))))))), ((ValueComparer)(((IProperty)boolToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(boolToStringConverterProperty)), ((ValueComparer)(((IProperty)boolToTwoValuesConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(boolToTwoValuesConverterProperty)), ((ValueComparer)(((IProperty)boolToZeroOneConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(boolToZeroOneConverterProperty)), (source.GetCurrentValue(bytes) == null ? null : ((ValueComparer)(((IProperty)bytes).GetValueComparer())).Snapshot(source.GetCurrentValue(bytes))), (((object)(source.GetCurrentValue(bytesArray))) == null ? null : ((byte[][])(((ValueComparer)(((IProperty)bytesArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(bytesArray))))))), (source.GetCurrentValue(bytesToStringConverterProperty) == null ? null : ((ValueComparer)(((IProperty)bytesToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(bytesToStringConverterProperty))), ((ValueComparer)(((IProperty)castingConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(castingConverterProperty)), ((ValueComparer)(((IProperty)@char).GetValueComparer())).Snapshot(source.GetCurrentValue(@char)), (((IEnumerable)(source.GetCurrentValue(charArray))) == null ? null : ((char[])(((ValueComparer>)(((IProperty)charArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(charArray))))))), ((ValueComparer)(((IProperty)charToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(charToStringConverterProperty)), ((ValueComparer)(((IProperty)dateOnly).GetValueComparer())).Snapshot(source.GetCurrentValue(dateOnly)), (((IEnumerable)(source.GetCurrentValue(dateOnlyArray))) == null ? null : ((DateOnly[])(((ValueComparer>)(((IProperty)dateOnlyArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(dateOnlyArray))))))), ((ValueComparer)(((IProperty)dateOnlyToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(dateOnlyToStringConverterProperty)), ((ValueComparer)(((IProperty)dateTime).GetValueComparer())).Snapshot(source.GetCurrentValue(dateTime)), (((IEnumerable)(source.GetCurrentValue(dateTimeArray))) == null ? null : ((DateTime[])(((ValueComparer>)(((IProperty)dateTimeArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(dateTimeArray))))))), ((ValueComparer)(((IProperty)dateTimeOffsetToBinaryConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(dateTimeOffsetToBinaryConverterProperty)), ((ValueComparer)(((IProperty)dateTimeOffsetToBytesConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(dateTimeOffsetToBytesConverterProperty)), ((ValueComparer)(((IProperty)dateTimeOffsetToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(dateTimeOffsetToStringConverterProperty)), ((ValueComparer)(((IProperty)dateTimeToBinaryConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(dateTimeToBinaryConverterProperty)), ((ValueComparer)(((IProperty)dateTimeToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(dateTimeToStringConverterProperty)), ((ValueComparer)(((IProperty)dateTimeToTicksConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(dateTimeToTicksConverterProperty)), ((ValueComparer)(((IProperty)@decimal).GetValueComparer())).Snapshot(source.GetCurrentValue(@decimal)), (((IEnumerable)(source.GetCurrentValue(decimalArray))) == null ? null : ((decimal[])(((ValueComparer>)(((IProperty)decimalArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(decimalArray))))))), ((ValueComparer)(((IProperty)decimalNumberToBytesConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(decimalNumberToBytesConverterProperty)), ((ValueComparer)(((IProperty)decimalNumberToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(decimalNumberToStringConverterProperty)), ((ValueComparer)(((IProperty)@double).GetValueComparer())).Snapshot(source.GetCurrentValue(@double)), (((IEnumerable)(source.GetCurrentValue(doubleArray))) == null ? null : ((double[])(((ValueComparer>)(((IProperty)doubleArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(doubleArray)))))))))); + var entity0 = ((CompiledModelTestBase.ManyTypes)(source.Entity)); + var liftedArg0 = ((ISnapshot)(new Snapshot, List, CompiledModelTestBase.Enum32, CompiledModelTestBase.Enum32[], CompiledModelTestBase.Enum32, CompiledModelTestBase.Enum32[], List, List, CompiledModelTestBase.Enum64, CompiledModelTestBase.Enum64[], CompiledModelTestBase.Enum64, CompiledModelTestBase.Enum64[], List, List, CompiledModelTestBase.Enum8, CompiledModelTestBase.Enum8[], CompiledModelTestBase.Enum8, CompiledModelTestBase.Enum8[], List, List, CompiledModelTestBase.Enum32, CompiledModelTestBase.Enum32, CompiledModelTestBase.EnumU16, CompiledModelTestBase.EnumU16[]>(((ValueComparer)(((IProperty)doubleNumberToBytesConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(doubleNumberToBytesConverterProperty)), ((ValueComparer)(((IProperty)doubleNumberToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(doubleNumberToStringConverterProperty)), ((ValueComparer)(((IProperty)enum16).GetValueComparer())).Snapshot(source.GetCurrentValue(enum16)), (((IEnumerable)(source.GetCurrentValue(enum16Array))) == null ? null : ((CompiledModelTestBase.Enum16[])(((ValueComparer>)(((IProperty)enum16Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enum16Array))))))), ((ValueComparer)(((IProperty)enum16AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(enum16AsString)), (((IEnumerable)(source.GetCurrentValue(enum16AsStringArray))) == null ? null : ((CompiledModelTestBase.Enum16[])(((ValueComparer>)(((IProperty)enum16AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enum16AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(enum16AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enum16AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enum16AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(enum16Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enum16Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enum16Collection))))))), ((ValueComparer)(((IProperty)enum32).GetValueComparer())).Snapshot(source.GetCurrentValue(enum32)), (((IEnumerable)(source.GetCurrentValue(enum32Array))) == null ? null : ((CompiledModelTestBase.Enum32[])(((ValueComparer>)(((IProperty)enum32Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enum32Array))))))), ((ValueComparer)(((IProperty)enum32AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(enum32AsString)), (((IEnumerable)(source.GetCurrentValue(enum32AsStringArray))) == null ? null : ((CompiledModelTestBase.Enum32[])(((ValueComparer>)(((IProperty)enum32AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enum32AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(enum32AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enum32AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enum32AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(enum32Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enum32Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enum32Collection))))))), ((ValueComparer)(((IProperty)enum64).GetValueComparer())).Snapshot(source.GetCurrentValue(enum64)), (((IEnumerable)(source.GetCurrentValue(enum64Array))) == null ? null : ((CompiledModelTestBase.Enum64[])(((ValueComparer>)(((IProperty)enum64Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enum64Array))))))), ((ValueComparer)(((IProperty)enum64AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(enum64AsString)), (((IEnumerable)(source.GetCurrentValue(enum64AsStringArray))) == null ? null : ((CompiledModelTestBase.Enum64[])(((ValueComparer>)(((IProperty)enum64AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enum64AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(enum64AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enum64AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enum64AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(enum64Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enum64Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enum64Collection))))))), ((ValueComparer)(((IProperty)enum8).GetValueComparer())).Snapshot(source.GetCurrentValue(enum8)), (((IEnumerable)(source.GetCurrentValue(enum8Array))) == null ? null : ((CompiledModelTestBase.Enum8[])(((ValueComparer>)(((IProperty)enum8Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enum8Array))))))), ((ValueComparer)(((IProperty)enum8AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(enum8AsString)), (((IEnumerable)(source.GetCurrentValue(enum8AsStringArray))) == null ? null : ((CompiledModelTestBase.Enum8[])(((ValueComparer>)(((IProperty)enum8AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enum8AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(enum8AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enum8AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enum8AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(enum8Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enum8Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enum8Collection))))))), ((ValueComparer)(((IProperty)enumToNumberConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(enumToNumberConverterProperty)), ((ValueComparer)(((IProperty)enumToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(enumToStringConverterProperty)), ((ValueComparer)(((IProperty)enumU16).GetValueComparer())).Snapshot(source.GetCurrentValue(enumU16)), (((IEnumerable)(source.GetCurrentValue(enumU16Array))) == null ? null : ((CompiledModelTestBase.EnumU16[])(((ValueComparer>)(((IProperty)enumU16Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enumU16Array)))))))))); + var entity1 = ((CompiledModelTestBase.ManyTypes)(source.Entity)); + var liftedArg1 = ((ISnapshot)(new Snapshot, List, CompiledModelTestBase.EnumU32, CompiledModelTestBase.EnumU32[], CompiledModelTestBase.EnumU32, CompiledModelTestBase.EnumU32[], List, List, CompiledModelTestBase.EnumU64, CompiledModelTestBase.EnumU64[], CompiledModelTestBase.EnumU64, CompiledModelTestBase.EnumU64[], List, List, CompiledModelTestBase.EnumU8, CompiledModelTestBase.EnumU8[], CompiledModelTestBase.EnumU8, CompiledModelTestBase.EnumU8[], List, List, float, float[], Guid, Guid[], Guid, Guid, IPAddress, IPAddress[]>(((ValueComparer)(((IProperty)enumU16AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(enumU16AsString)), (((IEnumerable)(source.GetCurrentValue(enumU16AsStringArray))) == null ? null : ((CompiledModelTestBase.EnumU16[])(((ValueComparer>)(((IProperty)enumU16AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enumU16AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(enumU16AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enumU16AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enumU16AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(enumU16Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enumU16Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enumU16Collection))))))), ((ValueComparer)(((IProperty)enumU32).GetValueComparer())).Snapshot(source.GetCurrentValue(enumU32)), (((IEnumerable)(source.GetCurrentValue(enumU32Array))) == null ? null : ((CompiledModelTestBase.EnumU32[])(((ValueComparer>)(((IProperty)enumU32Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enumU32Array))))))), ((ValueComparer)(((IProperty)enumU32AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(enumU32AsString)), (((IEnumerable)(source.GetCurrentValue(enumU32AsStringArray))) == null ? null : ((CompiledModelTestBase.EnumU32[])(((ValueComparer>)(((IProperty)enumU32AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enumU32AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(enumU32AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enumU32AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enumU32AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(enumU32Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enumU32Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enumU32Collection))))))), ((ValueComparer)(((IProperty)enumU64).GetValueComparer())).Snapshot(source.GetCurrentValue(enumU64)), (((IEnumerable)(source.GetCurrentValue(enumU64Array))) == null ? null : ((CompiledModelTestBase.EnumU64[])(((ValueComparer>)(((IProperty)enumU64Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enumU64Array))))))), ((ValueComparer)(((IProperty)enumU64AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(enumU64AsString)), (((IEnumerable)(source.GetCurrentValue(enumU64AsStringArray))) == null ? null : ((CompiledModelTestBase.EnumU64[])(((ValueComparer>)(((IProperty)enumU64AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enumU64AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(enumU64AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enumU64AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enumU64AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(enumU64Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enumU64Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enumU64Collection))))))), ((ValueComparer)(((IProperty)enumU8).GetValueComparer())).Snapshot(source.GetCurrentValue(enumU8)), (((IEnumerable)(source.GetCurrentValue(enumU8Array))) == null ? null : ((CompiledModelTestBase.EnumU8[])(((ValueComparer>)(((IProperty)enumU8Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enumU8Array))))))), ((ValueComparer)(((IProperty)enumU8AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(enumU8AsString)), (((IEnumerable)(source.GetCurrentValue(enumU8AsStringArray))) == null ? null : ((CompiledModelTestBase.EnumU8[])(((ValueComparer>)(((IProperty)enumU8AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(enumU8AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(enumU8AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enumU8AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enumU8AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(enumU8Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)enumU8Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(enumU8Collection))))))), ((ValueComparer)(((IProperty)@float).GetValueComparer())).Snapshot(source.GetCurrentValue(@float)), (((IEnumerable)(source.GetCurrentValue(floatArray))) == null ? null : ((float[])(((ValueComparer>)(((IProperty)floatArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(floatArray))))))), ((ValueComparer)(((IProperty)guid).GetValueComparer())).Snapshot(source.GetCurrentValue(guid)), (((IEnumerable)(source.GetCurrentValue(guidArray))) == null ? null : ((Guid[])(((ValueComparer>)(((IProperty)guidArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(guidArray))))))), ((ValueComparer)(((IProperty)guidToBytesConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(guidToBytesConverterProperty)), ((ValueComparer)(((IProperty)guidToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(guidToStringConverterProperty)), (source.GetCurrentValue(iPAddress) == null ? null : ((ValueComparer)(((IProperty)iPAddress).GetValueComparer())).Snapshot(source.GetCurrentValue(iPAddress))), (((object)(source.GetCurrentValue(iPAddressArray))) == null ? null : ((IPAddress[])(((ValueComparer)(((IProperty)iPAddressArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(iPAddressArray)))))))))); + var entity2 = ((CompiledModelTestBase.ManyTypes)(source.Entity)); + var liftedArg2 = ((ISnapshot)(new Snapshot((source.GetCurrentValue(iPAddressToBytesConverterProperty) == null ? null : ((ValueComparer)(((IProperty)iPAddressToBytesConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(iPAddressToBytesConverterProperty))), (source.GetCurrentValue(iPAddressToStringConverterProperty) == null ? null : ((ValueComparer)(((IProperty)iPAddressToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(iPAddressToStringConverterProperty))), ((ValueComparer)(((IProperty)int16).GetValueComparer())).Snapshot(source.GetCurrentValue(int16)), (((IEnumerable)(source.GetCurrentValue(int16Array))) == null ? null : ((short[])(((ValueComparer>)(((IProperty)int16Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(int16Array))))))), ((ValueComparer)(((IProperty)int32).GetValueComparer())).Snapshot(source.GetCurrentValue(int32)), (((IEnumerable)(source.GetCurrentValue(int32Array))) == null ? null : ((int[])(((ValueComparer>)(((IProperty)int32Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(int32Array))))))), ((ValueComparer)(((IProperty)int64).GetValueComparer())).Snapshot(source.GetCurrentValue(int64)), (((IEnumerable)(source.GetCurrentValue(int64Array))) == null ? null : ((long[])(((ValueComparer>)(((IProperty)int64Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(int64Array))))))), ((ValueComparer)(((IProperty)int8).GetValueComparer())).Snapshot(source.GetCurrentValue(int8)), (((IEnumerable)(source.GetCurrentValue(int8Array))) == null ? null : ((sbyte[])(((ValueComparer>)(((IProperty)int8Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(int8Array))))))), ((ValueComparer)(((IProperty)intNumberToBytesConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(intNumberToBytesConverterProperty)), ((ValueComparer)(((IProperty)intNumberToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(intNumberToStringConverterProperty)), (source.GetCurrentValue(nullIntToNullStringConverterProperty) == null ? null : ((ValueComparer)(((IProperty)nullIntToNullStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(nullIntToNullStringConverterProperty))), (source.GetCurrentValue(nullableBool) == null ? null : ((ValueComparer)(((IProperty)nullableBool).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableBool))), (((IEnumerable)(source.GetCurrentValue(nullableBoolArray))) == null ? null : ((bool? [])(((ValueComparer>)(((IProperty)nullableBoolArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableBoolArray))))))), (source.GetCurrentValue(nullableBytes) == null ? null : ((ValueComparer)(((IProperty)nullableBytes).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableBytes))), (((object)(source.GetCurrentValue(nullableBytesArray))) == null ? null : ((byte[][])(((ValueComparer)(((IProperty)nullableBytesArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(nullableBytesArray))))))), (source.GetCurrentValue(nullableChar) == null ? null : ((ValueComparer)(((IProperty)nullableChar).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableChar))), (((IEnumerable)(source.GetCurrentValue(nullableCharArray))) == null ? null : ((char? [])(((ValueComparer>)(((IProperty)nullableCharArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableCharArray))))))), (source.GetCurrentValue(nullableDateOnly) == null ? null : ((ValueComparer)(((IProperty)nullableDateOnly).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableDateOnly))), (((IEnumerable)(source.GetCurrentValue(nullableDateOnlyArray))) == null ? null : ((DateOnly? [])(((ValueComparer>)(((IProperty)nullableDateOnlyArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableDateOnlyArray))))))), (source.GetCurrentValue(nullableDateTime) == null ? null : ((ValueComparer)(((IProperty)nullableDateTime).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableDateTime))), (((IEnumerable)(source.GetCurrentValue(nullableDateTimeArray))) == null ? null : ((DateTime? [])(((ValueComparer>)(((IProperty)nullableDateTimeArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableDateTimeArray))))))), (source.GetCurrentValue(nullableDecimal) == null ? null : ((ValueComparer)(((IProperty)nullableDecimal).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableDecimal))), (((IEnumerable)(source.GetCurrentValue(nullableDecimalArray))) == null ? null : ((decimal? [])(((ValueComparer>)(((IProperty)nullableDecimalArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableDecimalArray))))))), (source.GetCurrentValue(nullableDouble) == null ? null : ((ValueComparer)(((IProperty)nullableDouble).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableDouble))), (((IEnumerable)(source.GetCurrentValue(nullableDoubleArray))) == null ? null : ((double? [])(((ValueComparer>)(((IProperty)nullableDoubleArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableDoubleArray))))))), (source.GetCurrentValue(nullableEnum16) == null ? null : ((ValueComparer)(((IProperty)nullableEnum16).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnum16))), (((IEnumerable)(source.GetCurrentValue(nullableEnum16Array))) == null ? null : ((CompiledModelTestBase.Enum16? [])(((ValueComparer>)(((IProperty)nullableEnum16Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnum16Array))))))), (source.GetCurrentValue(nullableEnum16AsString) == null ? null : ((ValueComparer)(((IProperty)nullableEnum16AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnum16AsString)))))); + var entity3 = ((CompiledModelTestBase.ManyTypes)(source.Entity)); + var liftedArg3 = ((ISnapshot)(new Snapshot, List, CompiledModelTestBase.Enum32?, CompiledModelTestBase.Enum32? [], CompiledModelTestBase.Enum32?, CompiledModelTestBase.Enum32? [], List, List, CompiledModelTestBase.Enum64?, CompiledModelTestBase.Enum64? [], CompiledModelTestBase.Enum64?, CompiledModelTestBase.Enum64? [], List, List, CompiledModelTestBase.Enum8?, CompiledModelTestBase.Enum8? [], CompiledModelTestBase.Enum8?, CompiledModelTestBase.Enum8? [], List, List, CompiledModelTestBase.EnumU16?, CompiledModelTestBase.EnumU16? [], CompiledModelTestBase.EnumU16?, CompiledModelTestBase.EnumU16? [], List, List, CompiledModelTestBase.EnumU32?, CompiledModelTestBase.EnumU32? [], CompiledModelTestBase.EnumU32?>((((IEnumerable)(source.GetCurrentValue(nullableEnum16AsStringArray))) == null ? null : ((CompiledModelTestBase.Enum16? [])(((ValueComparer>)(((IProperty)nullableEnum16AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnum16AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnum16AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnum16AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnum16AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnum16Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnum16Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnum16Collection))))))), (source.GetCurrentValue(nullableEnum32) == null ? null : ((ValueComparer)(((IProperty)nullableEnum32).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnum32))), (((IEnumerable)(source.GetCurrentValue(nullableEnum32Array))) == null ? null : ((CompiledModelTestBase.Enum32? [])(((ValueComparer>)(((IProperty)nullableEnum32Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnum32Array))))))), (source.GetCurrentValue(nullableEnum32AsString) == null ? null : ((ValueComparer)(((IProperty)nullableEnum32AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnum32AsString))), (((IEnumerable)(source.GetCurrentValue(nullableEnum32AsStringArray))) == null ? null : ((CompiledModelTestBase.Enum32? [])(((ValueComparer>)(((IProperty)nullableEnum32AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnum32AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnum32AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnum32AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnum32AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnum32Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnum32Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnum32Collection))))))), (source.GetCurrentValue(nullableEnum64) == null ? null : ((ValueComparer)(((IProperty)nullableEnum64).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnum64))), (((IEnumerable)(source.GetCurrentValue(nullableEnum64Array))) == null ? null : ((CompiledModelTestBase.Enum64? [])(((ValueComparer>)(((IProperty)nullableEnum64Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnum64Array))))))), (source.GetCurrentValue(nullableEnum64AsString) == null ? null : ((ValueComparer)(((IProperty)nullableEnum64AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnum64AsString))), (((IEnumerable)(source.GetCurrentValue(nullableEnum64AsStringArray))) == null ? null : ((CompiledModelTestBase.Enum64? [])(((ValueComparer>)(((IProperty)nullableEnum64AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnum64AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnum64AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnum64AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnum64AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnum64Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnum64Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnum64Collection))))))), (source.GetCurrentValue(nullableEnum8) == null ? null : ((ValueComparer)(((IProperty)nullableEnum8).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnum8))), (((IEnumerable)(source.GetCurrentValue(nullableEnum8Array))) == null ? null : ((CompiledModelTestBase.Enum8? [])(((ValueComparer>)(((IProperty)nullableEnum8Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnum8Array))))))), (source.GetCurrentValue(nullableEnum8AsString) == null ? null : ((ValueComparer)(((IProperty)nullableEnum8AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnum8AsString))), (((IEnumerable)(source.GetCurrentValue(nullableEnum8AsStringArray))) == null ? null : ((CompiledModelTestBase.Enum8? [])(((ValueComparer>)(((IProperty)nullableEnum8AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnum8AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnum8AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnum8AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnum8AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnum8Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnum8Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnum8Collection))))))), (source.GetCurrentValue(nullableEnumU16) == null ? null : ((ValueComparer)(((IProperty)nullableEnumU16).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnumU16))), (((IEnumerable)(source.GetCurrentValue(nullableEnumU16Array))) == null ? null : ((CompiledModelTestBase.EnumU16? [])(((ValueComparer>)(((IProperty)nullableEnumU16Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnumU16Array))))))), (source.GetCurrentValue(nullableEnumU16AsString) == null ? null : ((ValueComparer)(((IProperty)nullableEnumU16AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnumU16AsString))), (((IEnumerable)(source.GetCurrentValue(nullableEnumU16AsStringArray))) == null ? null : ((CompiledModelTestBase.EnumU16? [])(((ValueComparer>)(((IProperty)nullableEnumU16AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnumU16AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnumU16AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnumU16AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnumU16AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnumU16Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnumU16Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnumU16Collection))))))), (source.GetCurrentValue(nullableEnumU32) == null ? null : ((ValueComparer)(((IProperty)nullableEnumU32).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnumU32))), (((IEnumerable)(source.GetCurrentValue(nullableEnumU32Array))) == null ? null : ((CompiledModelTestBase.EnumU32? [])(((ValueComparer>)(((IProperty)nullableEnumU32Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnumU32Array))))))), (source.GetCurrentValue(nullableEnumU32AsString) == null ? null : ((ValueComparer)(((IProperty)nullableEnumU32AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnumU32AsString)))))); + var entity4 = ((CompiledModelTestBase.ManyTypes)(source.Entity)); + var liftedArg4 = ((ISnapshot)(new Snapshot, List, CompiledModelTestBase.EnumU64?, CompiledModelTestBase.EnumU64? [], CompiledModelTestBase.EnumU64?, CompiledModelTestBase.EnumU64? [], List, List, CompiledModelTestBase.EnumU8?, CompiledModelTestBase.EnumU8? [], CompiledModelTestBase.EnumU8?, CompiledModelTestBase.EnumU8? [], List, List, float?, float? [], Guid?, Guid? [], IPAddress, IPAddress[], short?, short? [], int?, int? [], long?, long? [], sbyte?, sbyte? [], PhysicalAddress>((((IEnumerable)(source.GetCurrentValue(nullableEnumU32AsStringArray))) == null ? null : ((CompiledModelTestBase.EnumU32? [])(((ValueComparer>)(((IProperty)nullableEnumU32AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnumU32AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnumU32AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnumU32AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnumU32AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnumU32Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnumU32Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnumU32Collection))))))), (source.GetCurrentValue(nullableEnumU64) == null ? null : ((ValueComparer)(((IProperty)nullableEnumU64).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnumU64))), (((IEnumerable)(source.GetCurrentValue(nullableEnumU64Array))) == null ? null : ((CompiledModelTestBase.EnumU64? [])(((ValueComparer>)(((IProperty)nullableEnumU64Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnumU64Array))))))), (source.GetCurrentValue(nullableEnumU64AsString) == null ? null : ((ValueComparer)(((IProperty)nullableEnumU64AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnumU64AsString))), (((IEnumerable)(source.GetCurrentValue(nullableEnumU64AsStringArray))) == null ? null : ((CompiledModelTestBase.EnumU64? [])(((ValueComparer>)(((IProperty)nullableEnumU64AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnumU64AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnumU64AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnumU64AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnumU64AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnumU64Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnumU64Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnumU64Collection))))))), (source.GetCurrentValue(nullableEnumU8) == null ? null : ((ValueComparer)(((IProperty)nullableEnumU8).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnumU8))), (((IEnumerable)(source.GetCurrentValue(nullableEnumU8Array))) == null ? null : ((CompiledModelTestBase.EnumU8? [])(((ValueComparer>)(((IProperty)nullableEnumU8Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnumU8Array))))))), (source.GetCurrentValue(nullableEnumU8AsString) == null ? null : ((ValueComparer)(((IProperty)nullableEnumU8AsString).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableEnumU8AsString))), (((IEnumerable)(source.GetCurrentValue(nullableEnumU8AsStringArray))) == null ? null : ((CompiledModelTestBase.EnumU8? [])(((ValueComparer>)(((IProperty)nullableEnumU8AsStringArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableEnumU8AsStringArray))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnumU8AsStringCollection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnumU8AsStringCollection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnumU8AsStringCollection))))))), (((IEnumerable)(source.GetCurrentValue>(nullableEnumU8Collection))) == null ? null : ((List)(((ValueComparer>)(((IProperty)nullableEnumU8Collection).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(nullableEnumU8Collection))))))), (source.GetCurrentValue(nullableFloat) == null ? null : ((ValueComparer)(((IProperty)nullableFloat).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableFloat))), (((IEnumerable)(source.GetCurrentValue(nullableFloatArray))) == null ? null : ((float? [])(((ValueComparer>)(((IProperty)nullableFloatArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableFloatArray))))))), (source.GetCurrentValue(nullableGuid) == null ? null : ((ValueComparer)(((IProperty)nullableGuid).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableGuid))), (((IEnumerable)(source.GetCurrentValue(nullableGuidArray))) == null ? null : ((Guid? [])(((ValueComparer>)(((IProperty)nullableGuidArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableGuidArray))))))), (source.GetCurrentValue(nullableIPAddress) == null ? null : ((ValueComparer)(((IProperty)nullableIPAddress).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableIPAddress))), (((object)(source.GetCurrentValue(nullableIPAddressArray))) == null ? null : ((IPAddress[])(((ValueComparer)(((IProperty)nullableIPAddressArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(nullableIPAddressArray))))))), (source.GetCurrentValue(nullableInt16) == null ? null : ((ValueComparer)(((IProperty)nullableInt16).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableInt16))), (((IEnumerable)(source.GetCurrentValue(nullableInt16Array))) == null ? null : ((short? [])(((ValueComparer>)(((IProperty)nullableInt16Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableInt16Array))))))), (source.GetCurrentValue(nullableInt32) == null ? null : ((ValueComparer)(((IProperty)nullableInt32).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableInt32))), (((IEnumerable)(source.GetCurrentValue(nullableInt32Array))) == null ? null : ((int? [])(((ValueComparer>)(((IProperty)nullableInt32Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableInt32Array))))))), (source.GetCurrentValue(nullableInt64) == null ? null : ((ValueComparer)(((IProperty)nullableInt64).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableInt64))), (((IEnumerable)(source.GetCurrentValue(nullableInt64Array))) == null ? null : ((long? [])(((ValueComparer>)(((IProperty)nullableInt64Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableInt64Array))))))), (source.GetCurrentValue(nullableInt8) == null ? null : ((ValueComparer)(((IProperty)nullableInt8).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableInt8))), (((IEnumerable)(source.GetCurrentValue(nullableInt8Array))) == null ? null : ((sbyte? [])(((ValueComparer>)(((IProperty)nullableInt8Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableInt8Array))))))), (source.GetCurrentValue(nullablePhysicalAddress) == null ? null : ((ValueComparer)(((IProperty)nullablePhysicalAddress).GetValueComparer())).Snapshot(source.GetCurrentValue(nullablePhysicalAddress)))))); + var entity5 = ((CompiledModelTestBase.ManyTypes)(source.Entity)); + var liftedArg5 = ((ISnapshot)(new Snapshot((((object)(source.GetCurrentValue(nullablePhysicalAddressArray))) == null ? null : ((PhysicalAddress[])(((ValueComparer)(((IProperty)nullablePhysicalAddressArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(nullablePhysicalAddressArray))))))), (source.GetCurrentValue(nullableString) == null ? null : ((ValueComparer)(((IProperty)nullableString).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableString))), (((object)(source.GetCurrentValue(nullableStringArray))) == null ? null : ((string[])(((ValueComparer)(((IProperty)nullableStringArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(nullableStringArray))))))), (source.GetCurrentValue(nullableTimeOnly) == null ? null : ((ValueComparer)(((IProperty)nullableTimeOnly).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableTimeOnly))), (((IEnumerable)(source.GetCurrentValue(nullableTimeOnlyArray))) == null ? null : ((TimeOnly? [])(((ValueComparer>)(((IProperty)nullableTimeOnlyArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableTimeOnlyArray))))))), (source.GetCurrentValue(nullableTimeSpan) == null ? null : ((ValueComparer)(((IProperty)nullableTimeSpan).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableTimeSpan))), (((IEnumerable)(source.GetCurrentValue(nullableTimeSpanArray))) == null ? null : ((TimeSpan? [])(((ValueComparer>)(((IProperty)nullableTimeSpanArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableTimeSpanArray))))))), (source.GetCurrentValue(nullableUInt16) == null ? null : ((ValueComparer)(((IProperty)nullableUInt16).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableUInt16))), (((IEnumerable)(source.GetCurrentValue(nullableUInt16Array))) == null ? null : ((ushort? [])(((ValueComparer>)(((IProperty)nullableUInt16Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableUInt16Array))))))), (source.GetCurrentValue(nullableUInt32) == null ? null : ((ValueComparer)(((IProperty)nullableUInt32).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableUInt32))), (((IEnumerable)(source.GetCurrentValue(nullableUInt32Array))) == null ? null : ((uint? [])(((ValueComparer>)(((IProperty)nullableUInt32Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableUInt32Array))))))), (source.GetCurrentValue(nullableUInt64) == null ? null : ((ValueComparer)(((IProperty)nullableUInt64).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableUInt64))), (((IEnumerable)(source.GetCurrentValue(nullableUInt64Array))) == null ? null : ((ulong? [])(((ValueComparer>)(((IProperty)nullableUInt64Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableUInt64Array))))))), (source.GetCurrentValue(nullableUInt8) == null ? null : ((ValueComparer)(((IProperty)nullableUInt8).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableUInt8))), (((IEnumerable)(source.GetCurrentValue(nullableUInt8Array))) == null ? null : ((byte? [])(((ValueComparer>)(((IProperty)nullableUInt8Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(nullableUInt8Array))))))), (source.GetCurrentValue(nullableUri) == null ? null : ((ValueComparer)(((IProperty)nullableUri).GetValueComparer())).Snapshot(source.GetCurrentValue(nullableUri))), (((object)(source.GetCurrentValue(nullableUriArray))) == null ? null : ((Uri[])(((ValueComparer)(((IProperty)nullableUriArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(nullableUriArray))))))), (source.GetCurrentValue(physicalAddress) == null ? null : ((ValueComparer)(((IProperty)physicalAddress).GetValueComparer())).Snapshot(source.GetCurrentValue(physicalAddress))), (((object)(source.GetCurrentValue(physicalAddressArray))) == null ? null : ((PhysicalAddress[])(((ValueComparer)(((IProperty)physicalAddressArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(physicalAddressArray))))))), (source.GetCurrentValue(physicalAddressToBytesConverterProperty) == null ? null : ((ValueComparer)(((IProperty)physicalAddressToBytesConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(physicalAddressToBytesConverterProperty))), (source.GetCurrentValue(physicalAddressToStringConverterProperty) == null ? null : ((ValueComparer)(((IProperty)physicalAddressToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(physicalAddressToStringConverterProperty))), (source.GetCurrentValue(@string) == null ? null : ((ValueComparer)(((IProperty)@string).GetValueComparer())).Snapshot(source.GetCurrentValue(@string))), (((object)(source.GetCurrentValue(stringArray))) == null ? null : ((string[])(((ValueComparer)(((IProperty)stringArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(stringArray))))))), (source.GetCurrentValue(stringToBoolConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToBoolConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToBoolConverterProperty))), (source.GetCurrentValue(stringToBytesConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToBytesConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToBytesConverterProperty))), (source.GetCurrentValue(stringToCharConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToCharConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToCharConverterProperty))), (source.GetCurrentValue(stringToDateOnlyConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToDateOnlyConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToDateOnlyConverterProperty))), (source.GetCurrentValue(stringToDateTimeConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToDateTimeConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToDateTimeConverterProperty))), (source.GetCurrentValue(stringToDateTimeOffsetConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToDateTimeOffsetConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToDateTimeOffsetConverterProperty))), (source.GetCurrentValue(stringToDecimalNumberConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToDecimalNumberConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToDecimalNumberConverterProperty)))))); + var entity6 = ((CompiledModelTestBase.ManyTypes)(source.Entity)); + return ((ISnapshot)(new MultiSnapshot(new ISnapshot[] { liftedArg, liftedArg0, liftedArg1, liftedArg2, liftedArg3, liftedArg4, liftedArg5, ((ISnapshot)(new Snapshot((source.GetCurrentValue(stringToDoubleNumberConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToDoubleNumberConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToDoubleNumberConverterProperty))), (source.GetCurrentValue(stringToEnumConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToEnumConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToEnumConverterProperty))), (source.GetCurrentValue(stringToGuidConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToGuidConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToGuidConverterProperty))), (source.GetCurrentValue(stringToIntNumberConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToIntNumberConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToIntNumberConverterProperty))), (source.GetCurrentValue(stringToTimeOnlyConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToTimeOnlyConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToTimeOnlyConverterProperty))), (source.GetCurrentValue(stringToTimeSpanConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToTimeSpanConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToTimeSpanConverterProperty))), (source.GetCurrentValue(stringToUriConverterProperty) == null ? null : ((ValueComparer)(((IProperty)stringToUriConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(stringToUriConverterProperty))), ((ValueComparer)(((IProperty)timeOnly).GetValueComparer())).Snapshot(source.GetCurrentValue(timeOnly)), (((IEnumerable)(source.GetCurrentValue(timeOnlyArray))) == null ? null : ((TimeOnly[])(((ValueComparer>)(((IProperty)timeOnlyArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(timeOnlyArray))))))), ((ValueComparer)(((IProperty)timeOnlyToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(timeOnlyToStringConverterProperty)), ((ValueComparer)(((IProperty)timeOnlyToTicksConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(timeOnlyToTicksConverterProperty)), ((ValueComparer)(((IProperty)timeSpan).GetValueComparer())).Snapshot(source.GetCurrentValue(timeSpan)), (((IEnumerable)(source.GetCurrentValue(timeSpanArray))) == null ? null : ((TimeSpan[])(((ValueComparer>)(((IProperty)timeSpanArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(timeSpanArray))))))), ((ValueComparer)(((IProperty)timeSpanToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(timeSpanToStringConverterProperty)), ((ValueComparer)(((IProperty)timeSpanToTicksConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(timeSpanToTicksConverterProperty)), ((ValueComparer)(((IProperty)uInt16).GetValueComparer())).Snapshot(source.GetCurrentValue(uInt16)), (((IEnumerable)(source.GetCurrentValue(uInt16Array))) == null ? null : ((ushort[])(((ValueComparer>)(((IProperty)uInt16Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(uInt16Array))))))), ((ValueComparer)(((IProperty)uInt32).GetValueComparer())).Snapshot(source.GetCurrentValue(uInt32)), (((IEnumerable)(source.GetCurrentValue(uInt32Array))) == null ? null : ((uint[])(((ValueComparer>)(((IProperty)uInt32Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(uInt32Array))))))), ((ValueComparer)(((IProperty)uInt64).GetValueComparer())).Snapshot(source.GetCurrentValue(uInt64)), (((IEnumerable)(source.GetCurrentValue(uInt64Array))) == null ? null : ((ulong[])(((ValueComparer>)(((IProperty)uInt64Array).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(uInt64Array))))))), ((ValueComparer)(((IProperty)uInt8).GetValueComparer())).Snapshot(source.GetCurrentValue(uInt8)), (source.GetCurrentValue(uInt8Array) == null ? null : ((ValueComparer)(((IProperty)uInt8Array).GetValueComparer())).Snapshot(source.GetCurrentValue(uInt8Array))), (source.GetCurrentValue(uri) == null ? null : ((ValueComparer)(((IProperty)uri).GetValueComparer())).Snapshot(source.GetCurrentValue(uri))), (((object)(source.GetCurrentValue(uriArray))) == null ? null : ((Uri[])(((ValueComparer)(((IProperty)uriArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(uriArray))))))), (source.GetCurrentValue(uriToStringConverterProperty) == null ? null : ((ValueComparer)(((IProperty)uriToStringConverterProperty).GetValueComparer())).Snapshot(source.GetCurrentValue(uriToStringConverterProperty)))))) }))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(default(CompiledModelTestBase.ManyTypesId)))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(CompiledModelTestBase.ManyTypesId))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => Snapshot.Empty); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => Snapshot.Empty); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.ManyTypes)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 236, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 236, + shadowCount: 0, + relationshipCount: 1, + storeGeneratedCount: 1); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/ManyTypesUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/ManyTypesUnsafeAccessors.cs new file mode 100644 index 000000000..821247791 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/ManyTypesUnsafeAccessors.cs @@ -0,0 +1,724 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.NetworkInformation; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class ManyTypesUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.ManyTypesId Id(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref bool Bool(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref bool[] BoolArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref bool BoolToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref bool BoolToTwoValuesConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref bool BoolToZeroOneConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[] Bytes(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[][] BytesArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[] BytesToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref int CastingConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref char Char(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref char[] CharArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref char CharToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateOnly DateOnly(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateOnly[] DateOnlyArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateOnly DateOnlyToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTime DateTime(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTime[] DateTimeArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTimeOffset DateTimeOffsetToBinaryConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTimeOffset DateTimeOffsetToBytesConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTimeOffset DateTimeOffsetToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTime DateTimeToBinaryConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTime DateTimeToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTime DateTimeToTicksConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref decimal Decimal(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref decimal[] DecimalArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref decimal DecimalNumberToBytesConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref decimal DecimalNumberToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref double Double(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref double[] DoubleArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref double DoubleNumberToBytesConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref double DoubleNumberToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum16 Enum16(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum16[] Enum16Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum16 Enum16AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum16[] Enum16AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List Enum16AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List Enum16Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32 Enum32(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32[] Enum32Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32 Enum32AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32[] Enum32AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List Enum32AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List Enum32Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum64 Enum64(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum64[] Enum64Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum64 Enum64AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum64[] Enum64AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List Enum64AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List Enum64Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum8 Enum8(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum8[] Enum8Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum8 Enum8AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum8[] Enum8AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List Enum8AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List Enum8Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32 EnumToNumberConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32 EnumToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU16 EnumU16(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU16[] EnumU16Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU16 EnumU16AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU16[] EnumU16AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List EnumU16AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List EnumU16Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU32 EnumU32(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU32[] EnumU32Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU32 EnumU32AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU32[] EnumU32AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List EnumU32AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List EnumU32Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU64 EnumU64(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU64[] EnumU64Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU64 EnumU64AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU64[] EnumU64AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List EnumU64AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List EnumU64Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU8 EnumU8(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU8[] EnumU8Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU8 EnumU8AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU8[] EnumU8AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List EnumU8AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List EnumU8Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref float Float(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref float[] FloatArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Guid Guid(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Guid[] GuidArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Guid GuidToBytesConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Guid GuidToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IPAddress IPAddress(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IPAddress[] IPAddressArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IPAddress IPAddressToBytesConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IPAddress IPAddressToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref short Int16(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref short[] Int16Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref int Int32(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref int[] Int32Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref long Int64(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref long[] Int64Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref sbyte Int8(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref sbyte[] Int8Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref int IntNumberToBytesConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref int IntNumberToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref int? NullIntToNullStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref bool? NullableBool(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref bool?[] NullableBoolArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[] NullableBytes(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[][] NullableBytesArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref char? NullableChar(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref char?[] NullableCharArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateOnly? NullableDateOnly(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateOnly?[] NullableDateOnlyArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTime? NullableDateTime(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTime?[] NullableDateTimeArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref decimal? NullableDecimal(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref decimal?[] NullableDecimalArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref double? NullableDouble(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref double?[] NullableDoubleArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum16? NullableEnum16(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum16?[] NullableEnum16Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum16? NullableEnum16AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum16?[] NullableEnum16AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnum16AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnum16Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32? NullableEnum32(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32?[] NullableEnum32Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32? NullableEnum32AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum32?[] NullableEnum32AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnum32AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnum32Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum64? NullableEnum64(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum64?[] NullableEnum64Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum64? NullableEnum64AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum64?[] NullableEnum64AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnum64AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnum64Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum8? NullableEnum8(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum8?[] NullableEnum8Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum8? NullableEnum8AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.Enum8?[] NullableEnum8AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnum8AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnum8Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU16? NullableEnumU16(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU16?[] NullableEnumU16Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU16? NullableEnumU16AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU16?[] NullableEnumU16AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnumU16AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnumU16Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU32? NullableEnumU32(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU32?[] NullableEnumU32Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU32? NullableEnumU32AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU32?[] NullableEnumU32AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnumU32AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnumU32Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU64? NullableEnumU64(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU64?[] NullableEnumU64Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU64? NullableEnumU64AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU64?[] NullableEnumU64AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnumU64AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnumU64Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU8? NullableEnumU8(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU8?[] NullableEnumU8Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU8? NullableEnumU8AsString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.EnumU8?[] NullableEnumU8AsStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnumU8AsStringCollection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List NullableEnumU8Collection(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref float? NullableFloat(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref float?[] NullableFloatArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Guid? NullableGuid(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Guid?[] NullableGuidArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IPAddress NullableIPAddress(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IPAddress[] NullableIPAddressArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref short? NullableInt16(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref short?[] NullableInt16Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref int? NullableInt32(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref int?[] NullableInt32Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref long? NullableInt64(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref long?[] NullableInt64Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref sbyte? NullableInt8(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref sbyte?[] NullableInt8Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref PhysicalAddress NullablePhysicalAddress(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref PhysicalAddress[] NullablePhysicalAddressArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string NullableString(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string[] NullableStringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeOnly? NullableTimeOnly(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeOnly?[] NullableTimeOnlyArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeSpan? NullableTimeSpan(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeSpan?[] NullableTimeSpanArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ushort? NullableUInt16(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ushort?[] NullableUInt16Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref uint? NullableUInt32(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref uint?[] NullableUInt32Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ulong? NullableUInt64(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ulong?[] NullableUInt64Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte? NullableUInt8(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte?[] NullableUInt8Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Uri NullableUri(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Uri[] NullableUriArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref PhysicalAddress PhysicalAddress(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref PhysicalAddress[] PhysicalAddressArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref PhysicalAddress PhysicalAddressToBytesConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref PhysicalAddress PhysicalAddressToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string String(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string[] StringArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToBoolConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToBytesConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToCharConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToDateOnlyConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToDateTimeConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToDateTimeOffsetConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToDecimalNumberConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToDoubleNumberConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToEnumConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToGuidConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToIntNumberConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToTimeOnlyConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToTimeSpanConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string StringToUriConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeOnly TimeOnly(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeOnly[] TimeOnlyArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeOnly TimeOnlyToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeOnly TimeOnlyToTicksConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeSpan TimeSpan(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeSpan[] TimeSpanArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeSpan TimeSpanToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TimeSpan TimeSpanToTicksConverterProperty(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ushort UInt16(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ushort[] UInt16Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref uint UInt32(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref uint[] UInt32Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ulong UInt64(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ulong[] UInt64Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte UInt8(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[] UInt8Array(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Uri Uri(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Uri[] UriArray(CompiledModelTestBase.ManyTypes @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref Uri UriToStringConverterProperty(CompiledModelTestBase.ManyTypes @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedType0EntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedType0EntityType.cs index c7859fd3c..6725b9588 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedType0EntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedType0EntityType.cs @@ -5,7 +5,10 @@ using System.Reflection; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.Storage.Json; @@ -17,7 +20,8 @@ namespace TestNamespace { - internal partial class OwnedType0EntityType + [EntityFrameworkInternal] + public partial class OwnedType0EntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -36,19 +40,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(long), afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: 0L); + principalDerivedId.SetAccessors( + long (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(0) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(0) && entry.ReadShadowValue(0) == 0L ? entry.ReadTemporaryValue(0) : entry.ReadShadowValue(0))), + long (InternalEntityEntry entry) => entry.ReadShadowValue(0), + long (InternalEntityEntry entry) => entry.ReadOriginalValue(principalDerivedId, 0), + long (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalDerivedId, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + principalDerivedId.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: 0, + relationshipIndex: 0, + storeGenerationIndex: 0); principalDerivedId.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), keyComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v)); + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + principalDerivedId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalDerivedId)); principalDerivedId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var principalDerivedAlternateId = runtimeEntityType.AddProperty( @@ -56,19 +73,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(Guid), afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + principalDerivedAlternateId.SetAccessors( + Guid (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(1) ? entry.ReadStoreGeneratedValue(1) : (entry.FlaggedAsTemporary(1) && entry.ReadShadowValue(1) == new Guid("00000000-0000-0000-0000-000000000000") ? entry.ReadTemporaryValue(1) : entry.ReadShadowValue(1))), + Guid (InternalEntityEntry entry) => entry.ReadShadowValue(1), + Guid (InternalEntityEntry entry) => entry.ReadOriginalValue(principalDerivedAlternateId, 1), + Guid (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalDerivedAlternateId, 1), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + principalDerivedAlternateId.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: 1, + relationshipIndex: 1, + storeGenerationIndex: 1); principalDerivedAlternateId.TypeMapping = MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v)); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)); + principalDerivedAlternateId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalDerivedAlternateId)); principalDerivedAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var id = runtimeEntityType.AddProperty( @@ -77,19 +107,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueGenerated: ValueGenerated.OnAdd, afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: 0); + id.SetAccessors( + int (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(2) ? entry.ReadStoreGeneratedValue(2) : (entry.FlaggedAsTemporary(2) && entry.ReadShadowValue(2) == 0 ? entry.ReadTemporaryValue(2) : entry.ReadShadowValue(2))), + int (InternalEntityEntry entry) => entry.ReadShadowValue(2), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 2), + int (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 2), + object (ValueBuffer valueBuffer) => valueBuffer[2]); + id.SetPropertyIndexes( + index: 2, + originalValueIndex: 2, + shadowIndex: 2, + relationshipIndex: 2, + storeGenerationIndex: 2); id.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); + id.SetCurrentValueComparer(new EntryCurrentValueComparer(id)); id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); var details = runtimeEntityType.AddProperty( @@ -98,19 +141,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Details", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_details", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + details.SetGetter( + string (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._details(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._details(entity) == null, + string (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._details(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._details(instance) == null); + details.SetSetter( + (CompiledModelTestBase.OwnedType entity, string value) => OwnedTypeUnsafeAccessors._details(entity) = value); + details.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, string value) => OwnedTypeUnsafeAccessors._details(entity) = value); + details.SetAccessors( + string (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._details(((CompiledModelTestBase.OwnedType)(entry.Entity))), + string (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._details(((CompiledModelTestBase.OwnedType)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(details, 3), + string (InternalEntityEntry entry) => entry.GetCurrentValue(details), + object (ValueBuffer valueBuffer) => valueBuffer[3]); + details.SetPropertyIndexes( + index: 3, + originalValueIndex: 3, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); details.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None); @@ -122,19 +186,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Number", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), sentinel: 0); + number.SetGetter( + int (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors.Number(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors.Number(entity) == 0, + int (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors.Number(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors.Number(instance) == 0); + number.SetSetter( + (CompiledModelTestBase.OwnedType entity, int value) => OwnedTypeUnsafeAccessors.Number(entity) = value); + number.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, int value) => OwnedTypeUnsafeAccessors.Number(entity) = value); + number.SetAccessors( + int (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors.Number(((CompiledModelTestBase.OwnedType)(entry.Entity))), + int (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors.Number(((CompiledModelTestBase.OwnedType)(entry.Entity))), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(number, 4), + int (InternalEntityEntry entry) => entry.GetCurrentValue(number), + object (ValueBuffer valueBuffer) => valueBuffer[4]); + number.SetPropertyIndexes( + index: 4, + originalValueIndex: 4, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); number.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); number.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var refTypeArray = runtimeEntityType.AddProperty( @@ -143,58 +228,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeArray", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + refTypeArray.SetGetter( + IPAddress[] (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeArray(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeArray(entity) == null, + IPAddress[] (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeArray(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeArray(instance) == null); + refTypeArray.SetSetter( + (CompiledModelTestBase.OwnedType entity, IPAddress[] value) => OwnedTypeUnsafeAccessors._refTypeArray(entity) = value); + refTypeArray.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IPAddress[] value) => OwnedTypeUnsafeAccessors._refTypeArray(entity) = value); + refTypeArray.SetAccessors( + IPAddress[] (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeArray(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeArray(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => entry.ReadOriginalValue(refTypeArray, 5), + IPAddress[] (InternalEntityEntry entry) => entry.GetCurrentValue(refTypeArray), + object (ValueBuffer valueBuffer) => valueBuffer[5]); + refTypeArray.SetPropertyIndexes( + index: 5, + originalValueIndex: 5, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); refTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var refTypeEnumerable = runtimeEntityType.AddProperty( @@ -203,39 +309,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeEnumerable", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + refTypeEnumerable.SetGetter( + IEnumerable (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeEnumerable(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeEnumerable(entity) == null, + IEnumerable (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeEnumerable(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeEnumerable(instance) == null); + refTypeEnumerable.SetSetter( + (CompiledModelTestBase.OwnedType entity, IEnumerable value) => OwnedTypeUnsafeAccessors._refTypeEnumerable(entity) = value); + refTypeEnumerable.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IEnumerable value) => OwnedTypeUnsafeAccessors._refTypeEnumerable(entity) = value); + refTypeEnumerable.SetAccessors( + IEnumerable (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeEnumerable(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeEnumerable(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeEnumerable, 6), + IEnumerable (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeEnumerable), + object (ValueBuffer valueBuffer) => valueBuffer[6]); + refTypeEnumerable.SetPropertyIndexes( + index: 6, + originalValueIndex: 6, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeEnumerable.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), + comparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, string>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, string>( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None)); @@ -247,39 +374,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeIList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + refTypeIList.SetGetter( + IList (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeIList(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeIList(entity) == null, + IList (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeIList(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeIList(instance) == null); + refTypeIList.SetSetter( + (CompiledModelTestBase.OwnedType entity, IList value) => OwnedTypeUnsafeAccessors._refTypeIList(entity) = value); + refTypeIList.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IList value) => OwnedTypeUnsafeAccessors._refTypeIList(entity) = value); + refTypeIList.SetAccessors( + IList (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeIList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IList (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeIList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IList (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeIList, 7), + IList (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeIList), + object (ValueBuffer valueBuffer) => valueBuffer[7]); + refTypeIList.SetPropertyIndexes( + index: 7, + originalValueIndex: 7, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeIList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), + comparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, string>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, string>( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None)); @@ -291,58 +439,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + refTypeList.SetGetter( + List (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeList(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeList(entity) == null, + List (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeList(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeList(instance) == null); + refTypeList.SetSetter( + (CompiledModelTestBase.OwnedType entity, List value) => OwnedTypeUnsafeAccessors._refTypeList(entity) = value); + refTypeList.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, List value) => OwnedTypeUnsafeAccessors._refTypeList(entity) = value); + refTypeList.SetAccessors( + List (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + List (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeList, 8), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeList), + object (ValueBuffer valueBuffer) => valueBuffer[8]); + refTypeList.SetPropertyIndexes( + index: 8, + originalValueIndex: 8, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), + comparer: new ListOfReferenceTypesComparer, IPAddress>(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer, IPAddress>(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, IPAddress>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, IPAddress>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, IPAddress>( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, IPAddress>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); refTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var valueTypeArray = runtimeEntityType.AddProperty( @@ -351,39 +520,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeArray", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + valueTypeArray.SetGetter( + DateTime[] (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeArray(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeArray(entity) == null, + DateTime[] (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeArray(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeArray(instance) == null); + valueTypeArray.SetSetter( + (CompiledModelTestBase.OwnedType entity, DateTime[] value) => OwnedTypeUnsafeAccessors._valueTypeArray(entity) = value); + valueTypeArray.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, DateTime[] value) => OwnedTypeUnsafeAccessors._valueTypeArray(entity) = value); + valueTypeArray.SetAccessors( + DateTime[] (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeArray(((CompiledModelTestBase.OwnedType)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeArray(((CompiledModelTestBase.OwnedType)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => entry.ReadOriginalValue(valueTypeArray, 9), + DateTime[] (InternalEntityEntry entry) => entry.GetCurrentValue(valueTypeArray), + object (ValueBuffer valueBuffer) => valueBuffer[9]); + valueTypeArray.SetPropertyIndexes( + index: 9, + originalValueIndex: 9, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v)), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonDateTimeReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonDateTimeReaderWriter.Instance), elementMapping: MySqlDateTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), keyComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), providerValueComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", precision: 6))); @@ -395,39 +585,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeEnumerable", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + valueTypeEnumerable.SetGetter( + IEnumerable (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(entity) == null, + IEnumerable (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(instance) == null); + valueTypeEnumerable.SetSetter( + (CompiledModelTestBase.OwnedType entity, IEnumerable value) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(entity) = value); + valueTypeEnumerable.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IEnumerable value) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(entity) = value); + valueTypeEnumerable.SetAccessors( + IEnumerable (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeEnumerable, 10), + IEnumerable (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeEnumerable), + object (ValueBuffer valueBuffer) => valueBuffer[10]); + valueTypeEnumerable.SetPropertyIndexes( + index: 10, + originalValueIndex: 10, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeEnumerable.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), + comparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + keyComparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, byte>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, byte>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), keyComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v))); + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))); valueTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var valueTypeIList = runtimeEntityType.AddProperty( @@ -436,39 +647,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + valueTypeIList.SetGetter( + IList (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors.ValueTypeIList(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors.ValueTypeIList(entity) == null, + IList (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors.ValueTypeIList(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors.ValueTypeIList(instance) == null); + valueTypeIList.SetSetter( + (CompiledModelTestBase.OwnedType entity, IList value) => OwnedTypeUnsafeAccessors.ValueTypeIList(entity) = value); + valueTypeIList.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IList value) => OwnedTypeUnsafeAccessors.ValueTypeIList(entity) = value); + valueTypeIList.SetAccessors( + IList (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors.ValueTypeIList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IList (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors.ValueTypeIList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IList (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeIList, 11), + IList (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeIList), + object (ValueBuffer valueBuffer) => valueBuffer[11]); + valueTypeIList.SetPropertyIndexes( + index: 11, + originalValueIndex: 11, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeIList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), + comparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + keyComparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, byte>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, byte>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), keyComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v))); + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))); valueTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var valueTypeList = runtimeEntityType.AddProperty( @@ -477,45 +709,72 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + valueTypeList.SetGetter( + List (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeList(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeList(entity) == null, + List (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeList(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeList(instance) == null); + valueTypeList.SetSetter( + (CompiledModelTestBase.OwnedType entity, List value) => OwnedTypeUnsafeAccessors._valueTypeList(entity) = value); + valueTypeList.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, List value) => OwnedTypeUnsafeAccessors._valueTypeList(entity) = value); + valueTypeList.SetAccessors( + List (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + List (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeList, 12), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeList), + object (ValueBuffer valueBuffer) => valueBuffer[12]); + valueTypeList.SetPropertyIndexes( + index: 12, + originalValueIndex: 12, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v)), + comparer: new ListOfValueTypesComparer, short>(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), + keyComparer: new ListOfValueTypesComparer, short>(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, short>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, short>( JsonInt16ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, short>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, short>( JsonInt16ReaderWriter.Instance), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), keyComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v))); + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v))); valueTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var context = runtimeEntityType.AddServiceProperty( "Context", propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Context", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), serviceType: typeof(DbContext)); + context.SetPropertyIndexes( + index: -1, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); var key = runtimeEntityType.AddKey( new[] { principalDerivedId, principalDerivedAlternateId, id }); @@ -540,11 +799,82 @@ public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEnt fieldInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetField("ManyOwned", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), eagerLoaded: true); + manyOwned.SetGetter( + ICollection (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.ManyOwned(entity), + bool (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.ManyOwned(entity) == null, + ICollection (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.ManyOwned(instance), + bool (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.ManyOwned(instance) == null); + manyOwned.SetSetter( + (CompiledModelTestBase.PrincipalDerived> entity, ICollection value) => PrincipalDerivedUnsafeAccessors>.ManyOwned(entity) = value); + manyOwned.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalDerived> entity, ICollection value) => PrincipalDerivedUnsafeAccessors>.ManyOwned(entity) = value); + manyOwned.SetAccessors( + ICollection (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.ManyOwned(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + ICollection (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.ManyOwned(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + null, + ICollection (InternalEntityEntry entry) => entry.GetCurrentValue>(manyOwned), + null); + manyOwned.SetPropertyIndexes( + index: 3, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 5, + storeGenerationIndex: -1); + manyOwned.SetCollectionAccessor>, ICollection, CompiledModelTestBase.OwnedType>( + ICollection (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.ManyOwned(entity), + (CompiledModelTestBase.PrincipalDerived> entity, ICollection collection) => PrincipalDerivedUnsafeAccessors>.ManyOwned(entity) = ((ICollection)(collection)), + (CompiledModelTestBase.PrincipalDerived> entity, ICollection collection) => PrincipalDerivedUnsafeAccessors>.ManyOwned(entity) = ((ICollection)(collection)), + ICollection (CompiledModelTestBase.PrincipalDerived> entity, Action>, ICollection> setter) => ClrCollectionAccessorFactory.CreateAndSetHashSet>, ICollection, CompiledModelTestBase.OwnedType>(entity, setter), + ICollection () => ((ICollection)(((ICollection)(new HashSet(ReferenceEqualityComparer.Instance)))))); return runtimeForeignKey; } public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var principalDerivedId = runtimeEntityType.FindProperty("PrincipalDerivedId"); + var principalDerivedAlternateId = runtimeEntityType.FindProperty("PrincipalDerivedAlternateId"); + var id = runtimeEntityType.FindProperty("Id"); + var details = runtimeEntityType.FindProperty("Details"); + var number = runtimeEntityType.FindProperty("Number"); + var refTypeArray = runtimeEntityType.FindProperty("RefTypeArray"); + var refTypeEnumerable = runtimeEntityType.FindProperty("RefTypeEnumerable"); + var refTypeIList = runtimeEntityType.FindProperty("RefTypeIList"); + var refTypeList = runtimeEntityType.FindProperty("RefTypeList"); + var valueTypeArray = runtimeEntityType.FindProperty("ValueTypeArray"); + var valueTypeEnumerable = runtimeEntityType.FindProperty("ValueTypeEnumerable"); + var valueTypeIList = runtimeEntityType.FindProperty("ValueTypeIList"); + var valueTypeList = runtimeEntityType.FindProperty("ValueTypeList"); + var key = runtimeEntityType.FindKey(new[] { principalDerivedId, principalDerivedAlternateId, id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateCompositeFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory>(key)); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.OwnedType)(source.Entity)); + return ((ISnapshot)(new Snapshot, IList, List, DateTime[], IEnumerable, IList, List>(((ValueComparer)(((IProperty)principalDerivedId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalDerivedId)), ((ValueComparer)(((IProperty)principalDerivedAlternateId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalDerivedAlternateId)), ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id)), (source.GetCurrentValue(details) == null ? null : ((ValueComparer)(((IProperty)details).GetValueComparer())).Snapshot(source.GetCurrentValue(details))), ((ValueComparer)(((IProperty)number).GetValueComparer())).Snapshot(source.GetCurrentValue(number)), (((object)(source.GetCurrentValue(refTypeArray))) == null ? null : ((IPAddress[])(((ValueComparer)(((IProperty)refTypeArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(refTypeArray))))))), (((object)(source.GetCurrentValue>(refTypeEnumerable))) == null ? null : ((IEnumerable)(((ValueComparer)(((IProperty)refTypeEnumerable).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeEnumerable))))))), (((object)(source.GetCurrentValue>(refTypeIList))) == null ? null : ((IList)(((ValueComparer)(((IProperty)refTypeIList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeIList))))))), (((object)(source.GetCurrentValue>(refTypeList))) == null ? null : ((List)(((ValueComparer)(((IProperty)refTypeList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeList))))))), (((IEnumerable)(source.GetCurrentValue(valueTypeArray))) == null ? null : ((DateTime[])(((ValueComparer>)(((IProperty)valueTypeArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(valueTypeArray))))))), (source.GetCurrentValue>(valueTypeEnumerable) == null ? null : ((ValueComparer>)(((IProperty)valueTypeEnumerable).GetValueComparer())).Snapshot(source.GetCurrentValue>(valueTypeEnumerable))), (((IEnumerable)(source.GetCurrentValue>(valueTypeIList))) == null ? null : ((IList)(((ValueComparer>)(((IProperty)valueTypeIList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeIList))))))), (((IEnumerable)(source.GetCurrentValue>(valueTypeList))) == null ? null : ((List)(((ValueComparer>)(((IProperty)valueTypeList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeList)))))))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalDerivedId).GetValueComparer())).Snapshot(default(long)), ((ValueComparer)(((IProperty)principalDerivedAlternateId).GetValueComparer())).Snapshot(default(Guid)), ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(default(int)))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(long), default(Guid), default(int))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("PrincipalDerivedId") ? ((long)(source["PrincipalDerivedId"])) : 0L), (source.ContainsKey("PrincipalDerivedAlternateId") ? ((Guid)(source["PrincipalDerivedAlternateId"])) : new Guid("00000000-0000-0000-0000-000000000000")), (source.ContainsKey("Id") ? ((int)(source["Id"])) : 0))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(long), default(Guid), default(int))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.OwnedType)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalDerivedId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalDerivedId)), ((ValueComparer)(((IProperty)principalDerivedAlternateId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalDerivedAlternateId)), ((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 13, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 13, + shadowCount: 3, + relationshipCount: 3, + storeGeneratedCount: 3); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedTypeEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedTypeEntityType.cs index e662a0cf5..4fe59f6d7 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedTypeEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedTypeEntityType.cs @@ -5,7 +5,10 @@ using System.Reflection; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.Storage.Json; @@ -17,7 +20,8 @@ namespace TestNamespace { - internal partial class OwnedTypeEntityType + [EntityFrameworkInternal] + public partial class OwnedTypeEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -38,19 +42,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyAccessMode: PropertyAccessMode.Field, afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: 0L); + principalBaseId.SetAccessors( + long (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(0) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(0) && entry.ReadShadowValue(0) == 0L ? entry.ReadTemporaryValue(0) : entry.ReadShadowValue(0))), + long (InternalEntityEntry entry) => entry.ReadShadowValue(0), + long (InternalEntityEntry entry) => entry.ReadOriginalValue(principalBaseId, 0), + long (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalBaseId, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + principalBaseId.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: 0, + relationshipIndex: 0, + storeGenerationIndex: 0); principalBaseId.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), keyComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v)); + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + principalBaseId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalBaseId)); var overrides = new StoreObjectDictionary(); var principalBaseIdPrincipalBase = new RuntimeRelationalPropertyOverrides( @@ -69,19 +86,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyAccessMode: PropertyAccessMode.Field, afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + principalBaseAlternateId.SetAccessors( + Guid (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(1) ? entry.ReadStoreGeneratedValue(1) : (entry.FlaggedAsTemporary(1) && entry.ReadShadowValue(1) == new Guid("00000000-0000-0000-0000-000000000000") ? entry.ReadTemporaryValue(1) : entry.ReadShadowValue(1))), + Guid (InternalEntityEntry entry) => entry.ReadShadowValue(1), + Guid (InternalEntityEntry entry) => entry.ReadOriginalValue(principalBaseAlternateId, 1), + Guid (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalBaseAlternateId, 1), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + principalBaseAlternateId.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: 1, + relationshipIndex: 1, + storeGenerationIndex: 1); principalBaseAlternateId.TypeMapping = MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v)); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)); + principalBaseAlternateId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalBaseAlternateId)); principalBaseAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var details = runtimeEntityType.AddProperty( @@ -91,19 +121,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_details", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, nullable: true); + details.SetGetter( + string (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._details(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._details(entity) == null, + string (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._details(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._details(instance) == null); + details.SetSetter( + (CompiledModelTestBase.OwnedType entity, string value) => OwnedTypeUnsafeAccessors._details(entity) = value); + details.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, string value) => OwnedTypeUnsafeAccessors._details(entity) = value); + details.SetAccessors( + string (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._details(((CompiledModelTestBase.OwnedType)(entry.Entity))), + string (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._details(((CompiledModelTestBase.OwnedType)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(details, 2), + string (InternalEntityEntry entry) => entry.GetCurrentValue(details), + object (ValueBuffer valueBuffer) => valueBuffer[2]); + details.SetPropertyIndexes( + index: 2, + originalValueIndex: 2, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); details.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None); @@ -126,19 +177,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, sentinel: 0); + number.SetGetter( + int (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors.Number(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors.Number(entity) == 0, + int (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors.Number(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors.Number(instance) == 0); + number.SetSetter( + (CompiledModelTestBase.OwnedType entity, int value) => OwnedTypeUnsafeAccessors.Number(entity) = value); + number.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, int value) => OwnedTypeUnsafeAccessors.Number(entity) = value); + number.SetAccessors( + int (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors.Number(((CompiledModelTestBase.OwnedType)(entry.Entity))), + int (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors.Number(((CompiledModelTestBase.OwnedType)(entry.Entity))), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(number, 3), + int (InternalEntityEntry entry) => entry.GetCurrentValue(number), + object (ValueBuffer valueBuffer) => valueBuffer[3]); + number.SetPropertyIndexes( + index: 3, + originalValueIndex: 3, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); number.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); number.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var refTypeArray = runtimeEntityType.AddProperty( @@ -148,58 +220,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeArray", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, nullable: true); + refTypeArray.SetGetter( + IPAddress[] (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeArray(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeArray(entity) == null, + IPAddress[] (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeArray(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeArray(instance) == null); + refTypeArray.SetSetter( + (CompiledModelTestBase.OwnedType entity, IPAddress[] value) => OwnedTypeUnsafeAccessors._refTypeArray(entity) = value); + refTypeArray.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IPAddress[] value) => OwnedTypeUnsafeAccessors._refTypeArray(entity) = value); + refTypeArray.SetAccessors( + IPAddress[] (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeArray(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeArray(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => entry.ReadOriginalValue(refTypeArray, 4), + IPAddress[] (InternalEntityEntry entry) => entry.GetCurrentValue(refTypeArray), + object (ValueBuffer valueBuffer) => valueBuffer[4]); + refTypeArray.SetPropertyIndexes( + index: 4, + originalValueIndex: 4, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); refTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var refTypeEnumerable = runtimeEntityType.AddProperty( @@ -209,39 +302,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeEnumerable", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, nullable: true); + refTypeEnumerable.SetGetter( + IEnumerable (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeEnumerable(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeEnumerable(entity) == null, + IEnumerable (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeEnumerable(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeEnumerable(instance) == null); + refTypeEnumerable.SetSetter( + (CompiledModelTestBase.OwnedType entity, IEnumerable value) => OwnedTypeUnsafeAccessors._refTypeEnumerable(entity) = value); + refTypeEnumerable.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IEnumerable value) => OwnedTypeUnsafeAccessors._refTypeEnumerable(entity) = value); + refTypeEnumerable.SetAccessors( + IEnumerable (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeEnumerable(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeEnumerable(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeEnumerable, 5), + IEnumerable (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeEnumerable), + object (ValueBuffer valueBuffer) => valueBuffer[5]); + refTypeEnumerable.SetPropertyIndexes( + index: 5, + originalValueIndex: 5, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeEnumerable.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), + comparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, string>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, string>( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None)); @@ -254,39 +368,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeIList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, nullable: true); + refTypeIList.SetGetter( + IList (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeIList(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeIList(entity) == null, + IList (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeIList(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeIList(instance) == null); + refTypeIList.SetSetter( + (CompiledModelTestBase.OwnedType entity, IList value) => OwnedTypeUnsafeAccessors._refTypeIList(entity) = value); + refTypeIList.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IList value) => OwnedTypeUnsafeAccessors._refTypeIList(entity) = value); + refTypeIList.SetAccessors( + IList (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeIList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IList (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeIList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IList (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeIList, 6), + IList (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeIList), + object (ValueBuffer valueBuffer) => valueBuffer[6]); + refTypeIList.SetPropertyIndexes( + index: 6, + originalValueIndex: 6, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeIList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), + comparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, string>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, string>( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None)); @@ -299,58 +434,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, nullable: true); + refTypeList.SetGetter( + List (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeList(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._refTypeList(entity) == null, + List (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeList(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._refTypeList(instance) == null); + refTypeList.SetSetter( + (CompiledModelTestBase.OwnedType entity, List value) => OwnedTypeUnsafeAccessors._refTypeList(entity) = value); + refTypeList.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, List value) => OwnedTypeUnsafeAccessors._refTypeList(entity) = value); + refTypeList.SetAccessors( + List (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + List (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._refTypeList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeList, 7), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeList), + object (ValueBuffer valueBuffer) => valueBuffer[7]); + refTypeList.SetPropertyIndexes( + index: 7, + originalValueIndex: 7, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), + comparer: new ListOfReferenceTypesComparer, IPAddress>(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer, IPAddress>(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, IPAddress>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, IPAddress>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, IPAddress>( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, IPAddress>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); refTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var valueTypeArray = runtimeEntityType.AddProperty( @@ -360,39 +516,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeArray", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, nullable: true); + valueTypeArray.SetGetter( + DateTime[] (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeArray(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeArray(entity) == null, + DateTime[] (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeArray(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeArray(instance) == null); + valueTypeArray.SetSetter( + (CompiledModelTestBase.OwnedType entity, DateTime[] value) => OwnedTypeUnsafeAccessors._valueTypeArray(entity) = value); + valueTypeArray.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, DateTime[] value) => OwnedTypeUnsafeAccessors._valueTypeArray(entity) = value); + valueTypeArray.SetAccessors( + DateTime[] (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeArray(((CompiledModelTestBase.OwnedType)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeArray(((CompiledModelTestBase.OwnedType)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => entry.ReadOriginalValue(valueTypeArray, 8), + DateTime[] (InternalEntityEntry entry) => entry.GetCurrentValue(valueTypeArray), + object (ValueBuffer valueBuffer) => valueBuffer[8]); + valueTypeArray.SetPropertyIndexes( + index: 8, + originalValueIndex: 8, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v)), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonDateTimeReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonDateTimeReaderWriter.Instance), elementMapping: MySqlDateTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), keyComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), providerValueComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", precision: 6))); @@ -405,39 +582,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeEnumerable", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, nullable: true); + valueTypeEnumerable.SetGetter( + IEnumerable (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(entity) == null, + IEnumerable (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(instance) == null); + valueTypeEnumerable.SetSetter( + (CompiledModelTestBase.OwnedType entity, IEnumerable value) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(entity) = value); + valueTypeEnumerable.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IEnumerable value) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(entity) = value); + valueTypeEnumerable.SetAccessors( + IEnumerable (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeEnumerable(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeEnumerable, 9), + IEnumerable (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeEnumerable), + object (ValueBuffer valueBuffer) => valueBuffer[9]); + valueTypeEnumerable.SetPropertyIndexes( + index: 9, + originalValueIndex: 9, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeEnumerable.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), + comparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + keyComparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, byte>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, byte>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), keyComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v))); + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))); valueTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var valueTypeIList = runtimeEntityType.AddProperty( @@ -447,39 +645,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, nullable: true); + valueTypeIList.SetGetter( + IList (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors.ValueTypeIList(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors.ValueTypeIList(entity) == null, + IList (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors.ValueTypeIList(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors.ValueTypeIList(instance) == null); + valueTypeIList.SetSetter( + (CompiledModelTestBase.OwnedType entity, IList value) => OwnedTypeUnsafeAccessors.ValueTypeIList(entity) = value); + valueTypeIList.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, IList value) => OwnedTypeUnsafeAccessors.ValueTypeIList(entity) = value); + valueTypeIList.SetAccessors( + IList (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors.ValueTypeIList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IList (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors.ValueTypeIList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + IList (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeIList, 10), + IList (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeIList), + object (ValueBuffer valueBuffer) => valueBuffer[10]); + valueTypeIList.SetPropertyIndexes( + index: 10, + originalValueIndex: 10, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeIList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), + comparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + keyComparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, byte>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, byte>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), keyComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v))); + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))); valueTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var valueTypeList = runtimeEntityType.AddProperty( @@ -489,45 +708,72 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), propertyAccessMode: PropertyAccessMode.Field, nullable: true); + valueTypeList.SetGetter( + List (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeList(entity), + bool (CompiledModelTestBase.OwnedType entity) => OwnedTypeUnsafeAccessors._valueTypeList(entity) == null, + List (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeList(instance), + bool (CompiledModelTestBase.OwnedType instance) => OwnedTypeUnsafeAccessors._valueTypeList(instance) == null); + valueTypeList.SetSetter( + (CompiledModelTestBase.OwnedType entity, List value) => OwnedTypeUnsafeAccessors._valueTypeList(entity) = value); + valueTypeList.SetMaterializationSetter( + (CompiledModelTestBase.OwnedType entity, List value) => OwnedTypeUnsafeAccessors._valueTypeList(entity) = value); + valueTypeList.SetAccessors( + List (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + List (InternalEntityEntry entry) => OwnedTypeUnsafeAccessors._valueTypeList(((CompiledModelTestBase.OwnedType)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeList, 11), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeList), + object (ValueBuffer valueBuffer) => valueBuffer[11]); + valueTypeList.SetPropertyIndexes( + index: 11, + originalValueIndex: 11, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v)), + comparer: new ListOfValueTypesComparer, short>(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), + keyComparer: new ListOfValueTypesComparer, short>(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, short>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, short>( JsonInt16ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, short>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, short>( JsonInt16ReaderWriter.Instance), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), keyComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v))); + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v))); valueTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var context = runtimeEntityType.AddServiceProperty( "Context", propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Context", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), serviceType: typeof(DbContext)); + context.SetPropertyIndexes( + index: -1, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); var key = runtimeEntityType.AddKey( new[] { principalBaseId, principalBaseAlternateId }); @@ -556,6 +802,27 @@ public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEnt propertyAccessMode: PropertyAccessMode.Field, eagerLoaded: true); + owned.SetGetter( + CompiledModelTestBase.OwnedType (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors._ownedField(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors._ownedField(entity) == null, + CompiledModelTestBase.OwnedType (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors._ownedField(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors._ownedField(instance) == null); + owned.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.OwnedType value) => PrincipalBaseUnsafeAccessors._ownedField(entity) = value); + owned.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.OwnedType value) => PrincipalBaseUnsafeAccessors._ownedField(entity) = value); + owned.SetAccessors( + CompiledModelTestBase.OwnedType (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors._ownedField(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.OwnedType (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors._ownedField(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + null, + CompiledModelTestBase.OwnedType (InternalEntityEntry entry) => entry.GetCurrentValue(owned), + null); + owned.SetPropertyIndexes( + index: 0, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 2, + storeGenerationIndex: -1); return runtimeForeignKey; } @@ -574,6 +841,49 @@ public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEnt public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var principalBaseId = runtimeEntityType.FindProperty("PrincipalBaseId"); + var principalBaseAlternateId = runtimeEntityType.FindProperty("PrincipalBaseAlternateId"); + var details = runtimeEntityType.FindProperty("Details"); + var number = runtimeEntityType.FindProperty("Number"); + var refTypeArray = runtimeEntityType.FindProperty("RefTypeArray"); + var refTypeEnumerable = runtimeEntityType.FindProperty("RefTypeEnumerable"); + var refTypeIList = runtimeEntityType.FindProperty("RefTypeIList"); + var refTypeList = runtimeEntityType.FindProperty("RefTypeList"); + var valueTypeArray = runtimeEntityType.FindProperty("ValueTypeArray"); + var valueTypeEnumerable = runtimeEntityType.FindProperty("ValueTypeEnumerable"); + var valueTypeIList = runtimeEntityType.FindProperty("ValueTypeIList"); + var valueTypeList = runtimeEntityType.FindProperty("ValueTypeList"); + var key = runtimeEntityType.FindKey(new[] { principalBaseId, principalBaseAlternateId }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateCompositeFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory>(key)); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.OwnedType)(source.Entity)); + return ((ISnapshot)(new Snapshot, IList, List, DateTime[], IEnumerable, IList, List>(((ValueComparer)(((IProperty)principalBaseId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalBaseId)), ((ValueComparer)(((IProperty)principalBaseAlternateId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalBaseAlternateId)), (source.GetCurrentValue(details) == null ? null : ((ValueComparer)(((IProperty)details).GetValueComparer())).Snapshot(source.GetCurrentValue(details))), ((ValueComparer)(((IProperty)number).GetValueComparer())).Snapshot(source.GetCurrentValue(number)), (((object)(source.GetCurrentValue(refTypeArray))) == null ? null : ((IPAddress[])(((ValueComparer)(((IProperty)refTypeArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(refTypeArray))))))), (((object)(source.GetCurrentValue>(refTypeEnumerable))) == null ? null : ((IEnumerable)(((ValueComparer)(((IProperty)refTypeEnumerable).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeEnumerable))))))), (((object)(source.GetCurrentValue>(refTypeIList))) == null ? null : ((IList)(((ValueComparer)(((IProperty)refTypeIList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeIList))))))), (((object)(source.GetCurrentValue>(refTypeList))) == null ? null : ((List)(((ValueComparer)(((IProperty)refTypeList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeList))))))), (((IEnumerable)(source.GetCurrentValue(valueTypeArray))) == null ? null : ((DateTime[])(((ValueComparer>)(((IProperty)valueTypeArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(valueTypeArray))))))), (source.GetCurrentValue>(valueTypeEnumerable) == null ? null : ((ValueComparer>)(((IProperty)valueTypeEnumerable).GetValueComparer())).Snapshot(source.GetCurrentValue>(valueTypeEnumerable))), (((IEnumerable)(source.GetCurrentValue>(valueTypeIList))) == null ? null : ((IList)(((ValueComparer>)(((IProperty)valueTypeIList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeIList))))))), (((IEnumerable)(source.GetCurrentValue>(valueTypeList))) == null ? null : ((List)(((ValueComparer>)(((IProperty)valueTypeList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeList)))))))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalBaseId).GetValueComparer())).Snapshot(default(long)), ((ValueComparer)(((IProperty)principalBaseAlternateId).GetValueComparer())).Snapshot(default(Guid)))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(long), default(Guid))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("PrincipalBaseId") ? ((long)(source["PrincipalBaseId"])) : 0L), (source.ContainsKey("PrincipalBaseAlternateId") ? ((Guid)(source["PrincipalBaseAlternateId"])) : new Guid("00000000-0000-0000-0000-000000000000")))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(long), default(Guid))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.OwnedType)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)principalBaseId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalBaseId)), ((ValueComparer)(((IProperty)principalBaseAlternateId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalBaseAlternateId))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 12, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 12, + shadowCount: 2, + relationshipCount: 2, + storeGeneratedCount: 2); var fragments = new StoreObjectDictionary(); var detailsFragment = new RuntimeEntityTypeMappingFragment( runtimeEntityType, diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedTypeUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedTypeUnsafeAccessors.cs new file mode 100644 index 000000000..ed8d21e39 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/OwnedTypeUnsafeAccessors.cs @@ -0,0 +1,45 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class OwnedTypeUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_details")] + public static extern ref string _details(CompiledModelTestBase.OwnedType @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref int Number(CompiledModelTestBase.OwnedType @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_refTypeArray")] + public static extern ref IPAddress[] _refTypeArray(CompiledModelTestBase.OwnedType @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_refTypeEnumerable")] + public static extern ref IEnumerable _refTypeEnumerable(CompiledModelTestBase.OwnedType @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_refTypeIList")] + public static extern ref IList _refTypeIList(CompiledModelTestBase.OwnedType @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_refTypeList")] + public static extern ref List _refTypeList(CompiledModelTestBase.OwnedType @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_valueTypeArray")] + public static extern ref DateTime[] _valueTypeArray(CompiledModelTestBase.OwnedType @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_valueTypeEnumerable")] + public static extern ref IEnumerable _valueTypeEnumerable(CompiledModelTestBase.OwnedType @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IList ValueTypeIList(CompiledModelTestBase.OwnedType @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_valueTypeList")] + public static extern ref List _valueTypeList(CompiledModelTestBase.OwnedType @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBaseEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBaseEntityType.cs index 108949728..f430acf38 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBaseEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBaseEntityType.cs @@ -5,7 +5,10 @@ using System.Reflection; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.Storage.Json; @@ -18,7 +21,8 @@ namespace TestNamespace { - internal partial class PrincipalBaseEntityType + [EntityFrameworkInternal] + public partial class PrincipalBaseEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -40,19 +44,43 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), afterSaveBehavior: PropertySaveBehavior.Throw); + id.SetGetter( + long? (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Id(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => !(PrincipalBaseUnsafeAccessors.Id(entity).HasValue), + long? (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Id(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => !(PrincipalBaseUnsafeAccessors.Id(instance).HasValue)); + id.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, long? value) => PrincipalBaseUnsafeAccessors.Id(entity) = value); + id.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, long? value) => PrincipalBaseUnsafeAccessors.Id(entity) = value); + id.SetAccessors( + long? (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(0) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(0) && !(PrincipalBaseUnsafeAccessors.Id(((CompiledModelTestBase.PrincipalBase)(entry.Entity))).HasValue) ? entry.ReadTemporaryValue(0) : PrincipalBaseUnsafeAccessors.Id(((CompiledModelTestBase.PrincipalBase)(entry.Entity))))), + long? (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Id(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + long? (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 0), + long? (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + id.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: -1, + relationshipIndex: 0, + storeGenerationIndex: 0); id.TypeMapping = MySqlLongTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (long)v1 == (long)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((long)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(long)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (long)v1 == (long)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((long)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(long)v : default(Nullable)), - providerValueComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && (long)v1 == (long)v2 || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((long)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(long)v : default(Nullable))); + comparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + keyComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + providerValueComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + id.SetCurrentValueComparer(new EntryCurrentValueComparer(id)); + id.SetComparer(new NullableValueComparer(id.TypeMapping.Comparer)); + id.SetKeyComparer(new NullableValueComparer(id.TypeMapping.KeyComparer)); var overrides = new StoreObjectDictionary(); var idPrincipalDerived = new RuntimeRelationalPropertyOverrides( @@ -73,19 +101,41 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: new Guid("00000000-0000-0000-0000-000000000000"), jsonValueReaderWriter: JsonGuidReaderWriter.Instance); + alternateId.SetGetter( + Guid (CompiledModelTestBase.PrincipalBase entity) => entity.AlternateId, + bool (CompiledModelTestBase.PrincipalBase entity) => entity.AlternateId == new Guid("00000000-0000-0000-0000-000000000000"), + Guid (CompiledModelTestBase.PrincipalBase instance) => instance.AlternateId, + bool (CompiledModelTestBase.PrincipalBase instance) => instance.AlternateId == new Guid("00000000-0000-0000-0000-000000000000")); + alternateId.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, Guid value) => entity.AlternateId = value); + alternateId.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, Guid value) => entity.AlternateId = value); + alternateId.SetAccessors( + Guid (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(1) ? entry.ReadStoreGeneratedValue(1) : (entry.FlaggedAsTemporary(1) && ((CompiledModelTestBase.PrincipalBase)(entry.Entity)).AlternateId == new Guid("00000000-0000-0000-0000-000000000000") ? entry.ReadTemporaryValue(1) : ((CompiledModelTestBase.PrincipalBase)(entry.Entity)).AlternateId)), + Guid (InternalEntityEntry entry) => ((CompiledModelTestBase.PrincipalBase)(entry.Entity)).AlternateId, + Guid (InternalEntityEntry entry) => entry.ReadOriginalValue(alternateId, 1), + Guid (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(alternateId, 1), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + alternateId.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: -1, + relationshipIndex: 1, + storeGenerationIndex: 1); alternateId.TypeMapping = MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v)); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)); + alternateId.SetCurrentValueComparer(new EntryCurrentValueComparer(alternateId)); alternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var enum1 = runtimeEntityType.AddProperty( @@ -93,27 +143,48 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.AnEnum), propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Enum1", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum1.SetGetter( + CompiledModelTestBase.AnEnum (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Enum1(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.Enum1(entity))), ((object)((CompiledModelTestBase.AnEnum)0L))), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Enum1(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.Enum1(instance))), ((object)((CompiledModelTestBase.AnEnum)0L)))); + enum1.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AnEnum value) => PrincipalBaseUnsafeAccessors.Enum1(entity) = value); + enum1.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AnEnum value) => PrincipalBaseUnsafeAccessors.Enum1(entity) = value); + enum1.SetAccessors( + CompiledModelTestBase.AnEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Enum1(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AnEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Enum1(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AnEnum (InternalEntityEntry entry) => entry.ReadOriginalValue(enum1, 2), + CompiledModelTestBase.AnEnum (InternalEntityEntry entry) => entry.GetCurrentValue(enum1), + object (ValueBuffer valueBuffer) => valueBuffer[2]); + enum1.SetPropertyIndexes( + index: 2, + originalValueIndex: 2, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum1.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.AnEnum v) => v.GetHashCode(), - (CompiledModelTestBase.AnEnum v) => v), + bool (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AnEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.AnEnum v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.AnEnum v) => v.GetHashCode(), - (CompiledModelTestBase.AnEnum v) => v), + bool (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AnEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.AnEnum v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.AnEnum value) => (int)value, - (int value) => (CompiledModelTestBase.AnEnum)value), + int (CompiledModelTestBase.AnEnum value) => ((int)(value)), + CompiledModelTestBase.AnEnum (int value) => ((CompiledModelTestBase.AnEnum)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.AnEnum value) => (int)value, - (int value) => (CompiledModelTestBase.AnEnum)value))); + int (CompiledModelTestBase.AnEnum value) => ((int)(value)), + CompiledModelTestBase.AnEnum (int value) => ((CompiledModelTestBase.AnEnum)(value))))); enum1.SetSentinelFromProviderValue(0); enum1.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -123,27 +194,50 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Enum2", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + enum2.SetGetter( + CompiledModelTestBase.AnEnum? (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Enum2(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => !(PrincipalBaseUnsafeAccessors.Enum2(entity).HasValue), + CompiledModelTestBase.AnEnum? (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Enum2(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => !(PrincipalBaseUnsafeAccessors.Enum2(instance).HasValue)); + enum2.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AnEnum? value) => PrincipalBaseUnsafeAccessors.Enum2(entity) = (value == null ? value : ((CompiledModelTestBase.AnEnum? )(((CompiledModelTestBase.AnEnum)(value)))))); + enum2.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AnEnum? value) => PrincipalBaseUnsafeAccessors.Enum2(entity) = (value == null ? value : ((CompiledModelTestBase.AnEnum? )(((CompiledModelTestBase.AnEnum)(value)))))); + enum2.SetAccessors( + CompiledModelTestBase.AnEnum? (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Enum2(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AnEnum? (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Enum2(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AnEnum? (InternalEntityEntry entry) => entry.ReadOriginalValue(enum2, 3), + CompiledModelTestBase.AnEnum? (InternalEntityEntry entry) => entry.GetCurrentValue(enum2), + object (ValueBuffer valueBuffer) => valueBuffer[3]); + enum2.SetPropertyIndexes( + index: 3, + originalValueIndex: 3, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); enum2.TypeMapping = MySqlIntTypeMapping.Default.Clone( - comparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.AnEnum)v1, (object)(CompiledModelTestBase.AnEnum)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.AnEnum)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.AnEnum)v : default(Nullable)), - keyComparer: new ValueComparer( - (Nullable v1, Nullable v2) => v1.HasValue && v2.HasValue && object.Equals((object)(CompiledModelTestBase.AnEnum)v1, (object)(CompiledModelTestBase.AnEnum)v2) || !v1.HasValue && !v2.HasValue, - (Nullable v) => v.HasValue ? ((CompiledModelTestBase.AnEnum)v).GetHashCode() : 0, - (Nullable v) => v.HasValue ? (Nullable)(CompiledModelTestBase.AnEnum)v : default(Nullable)), + comparer: new ValueComparer( + bool (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AnEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.AnEnum v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AnEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.AnEnum v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.AnEnum value) => (int)value, - (int value) => (CompiledModelTestBase.AnEnum)value), + int (CompiledModelTestBase.AnEnum value) => ((int)(value)), + CompiledModelTestBase.AnEnum (int value) => ((CompiledModelTestBase.AnEnum)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.AnEnum value) => (int)value, - (int value) => (CompiledModelTestBase.AnEnum)value))); + int (CompiledModelTestBase.AnEnum value) => ((int)(value)), + CompiledModelTestBase.AnEnum (int value) => ((CompiledModelTestBase.AnEnum)(value))))); + enum2.SetComparer(new NullableValueComparer(enum2.TypeMapping.Comparer)); + enum2.SetKeyComparer(new NullableValueComparer(enum2.TypeMapping.KeyComparer)); enum2.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var flagsEnum1 = runtimeEntityType.AddProperty( @@ -151,56 +245,99 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.AFlagsEnum), propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("FlagsEnum1", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + flagsEnum1.SetGetter( + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.FlagsEnum1(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.FlagsEnum1(entity))), ((object)((CompiledModelTestBase.AFlagsEnum)0L))), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.FlagsEnum1(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.FlagsEnum1(instance))), ((object)((CompiledModelTestBase.AFlagsEnum)0L)))); + flagsEnum1.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AFlagsEnum value) => PrincipalBaseUnsafeAccessors.FlagsEnum1(entity) = value); + flagsEnum1.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AFlagsEnum value) => PrincipalBaseUnsafeAccessors.FlagsEnum1(entity) = value); + flagsEnum1.SetAccessors( + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.FlagsEnum1(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.FlagsEnum1(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => entry.ReadOriginalValue(flagsEnum1, 4), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => entry.GetCurrentValue(flagsEnum1), + object (ValueBuffer valueBuffer) => valueBuffer[4]); + flagsEnum1.SetPropertyIndexes( + index: 4, + originalValueIndex: 4, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); flagsEnum1.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.AFlagsEnum v) => v.GetHashCode(), - (CompiledModelTestBase.AFlagsEnum v) => v), + bool (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AFlagsEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.AFlagsEnum v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.AFlagsEnum v) => v.GetHashCode(), - (CompiledModelTestBase.AFlagsEnum v) => v), + bool (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AFlagsEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.AFlagsEnum v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.AFlagsEnum value) => (int)value, - (int value) => (CompiledModelTestBase.AFlagsEnum)value), + int (CompiledModelTestBase.AFlagsEnum value) => ((int)(value)), + CompiledModelTestBase.AFlagsEnum (int value) => ((CompiledModelTestBase.AFlagsEnum)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.AFlagsEnum value) => (int)value, - (int value) => (CompiledModelTestBase.AFlagsEnum)value))); + int (CompiledModelTestBase.AFlagsEnum value) => ((int)(value)), + CompiledModelTestBase.AFlagsEnum (int value) => ((CompiledModelTestBase.AFlagsEnum)(value))))); flagsEnum1.SetSentinelFromProviderValue(0); flagsEnum1.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var flagsEnum2 = runtimeEntityType.AddProperty( "FlagsEnum2", typeof(CompiledModelTestBase.AFlagsEnum), - propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("FlagsEnum2", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), - fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("FlagsEnum2", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Property); + flagsEnum2.SetGetter( + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Get_FlagsEnum2(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.Get_FlagsEnum2(entity))), ((object)(CompiledModelTestBase.AFlagsEnum.B | CompiledModelTestBase.AFlagsEnum.C))), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Get_FlagsEnum2(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.Get_FlagsEnum2(instance))), ((object)(CompiledModelTestBase.AFlagsEnum.B | CompiledModelTestBase.AFlagsEnum.C)))); + flagsEnum2.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AFlagsEnum value) => PrincipalBaseUnsafeAccessors.Set_FlagsEnum2(entity, value)); + flagsEnum2.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AFlagsEnum value) => PrincipalBaseUnsafeAccessors.Set_FlagsEnum2(entity, value)); + flagsEnum2.SetAccessors( + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Get_FlagsEnum2(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Get_FlagsEnum2(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => entry.ReadOriginalValue(flagsEnum2, 5), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => entry.GetCurrentValue(flagsEnum2), + object (ValueBuffer valueBuffer) => valueBuffer[5]); + flagsEnum2.SetPropertyIndexes( + index: 5, + originalValueIndex: 5, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); flagsEnum2.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.AFlagsEnum v) => v.GetHashCode(), - (CompiledModelTestBase.AFlagsEnum v) => v), + bool (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AFlagsEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.AFlagsEnum v) => v), keyComparer: new ValueComparer( - (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals((object)v1, (object)v2), - (CompiledModelTestBase.AFlagsEnum v) => v.GetHashCode(), - (CompiledModelTestBase.AFlagsEnum v) => v), + bool (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AFlagsEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.AFlagsEnum v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), converter: new ValueConverter( - (CompiledModelTestBase.AFlagsEnum value) => (int)value, - (int value) => (CompiledModelTestBase.AFlagsEnum)value), + int (CompiledModelTestBase.AFlagsEnum value) => ((int)(value)), + CompiledModelTestBase.AFlagsEnum (int value) => ((CompiledModelTestBase.AFlagsEnum)(value))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonInt32ReaderWriter.Instance, new ValueConverter( - (CompiledModelTestBase.AFlagsEnum value) => (int)value, - (int value) => (CompiledModelTestBase.AFlagsEnum)value))); + int (CompiledModelTestBase.AFlagsEnum value) => ((int)(value)), + CompiledModelTestBase.AFlagsEnum (int value) => ((CompiledModelTestBase.AFlagsEnum)(value))))); flagsEnum2.SetSentinelFromProviderValue(6); flagsEnum2.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); @@ -212,6 +349,18 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueConverter: new CastingConverter(), valueComparer: new CompiledModelTestBase.CustomValueComparer(), providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + point.SetAccessors( + Point (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(6) ? entry.ReadStoreGeneratedValue(2) : (entry.FlaggedAsTemporary(6) && entry.ReadShadowValue(0) == null ? entry.ReadTemporaryValue(2) : entry.ReadShadowValue(0))), + Point (InternalEntityEntry entry) => entry.ReadShadowValue(0), + Point (InternalEntityEntry entry) => entry.ReadOriginalValue(point, 6), + Point (InternalEntityEntry entry) => entry.GetCurrentValue(point), + object (ValueBuffer valueBuffer) => valueBuffer[6]); + point.SetPropertyIndexes( + index: 6, + originalValueIndex: 6, + shadowIndex: 0, + relationshipIndex: -1, + storeGenerationIndex: 2); point.TypeMapping = null; point.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); point.AddAnnotation("Relational:ColumnType", "geometry"); @@ -223,58 +372,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + refTypeArray.SetGetter( + IPAddress[] (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeArray(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeArray(entity) == null, + IPAddress[] (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeArray(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeArray(instance) == null); + refTypeArray.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IPAddress[] value) => PrincipalBaseUnsafeAccessors.RefTypeArray(entity) = value); + refTypeArray.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IPAddress[] value) => PrincipalBaseUnsafeAccessors.RefTypeArray(entity) = value); + refTypeArray.SetAccessors( + IPAddress[] (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeArray(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeArray(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => entry.ReadOriginalValue(refTypeArray, 7), + IPAddress[] (InternalEntityEntry entry) => entry.GetCurrentValue(refTypeArray), + object (ValueBuffer valueBuffer) => valueBuffer[7]); + refTypeArray.SetPropertyIndexes( + index: 7, + originalValueIndex: 7, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); refTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var refTypeEnumerable = runtimeEntityType.AddProperty( @@ -283,39 +453,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + refTypeEnumerable.SetGetter( + IEnumerable (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(entity) == null, + IEnumerable (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(instance) == null); + refTypeEnumerable.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IEnumerable value) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(entity) = value); + refTypeEnumerable.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IEnumerable value) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(entity) = value); + refTypeEnumerable.SetAccessors( + IEnumerable (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeEnumerable, 8), + IEnumerable (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeEnumerable), + object (ValueBuffer valueBuffer) => valueBuffer[8]); + refTypeEnumerable.SetPropertyIndexes( + index: 8, + originalValueIndex: 8, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeEnumerable.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), + comparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, string>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, string>( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None)); @@ -327,39 +518,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + refTypeIList.SetGetter( + IList (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeIList(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeIList(entity) == null, + IList (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeIList(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeIList(instance) == null); + refTypeIList.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IList value) => PrincipalBaseUnsafeAccessors.RefTypeIList(entity) = value); + refTypeIList.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IList value) => PrincipalBaseUnsafeAccessors.RefTypeIList(entity) = value); + refTypeIList.SetAccessors( + IList (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeIList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IList (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeIList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IList (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeIList, 9), + IList (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeIList), + object (ValueBuffer valueBuffer) => valueBuffer[9]); + refTypeIList.SetPropertyIndexes( + index: 9, + originalValueIndex: 9, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeIList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v)), + comparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, string>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, string>( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, string>( JsonStringReaderWriter.Instance), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None)); @@ -371,58 +583,79 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + refTypeList.SetGetter( + List (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeList(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeList(entity) == null, + List (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeList(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeList(instance) == null); + refTypeList.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, List value) => PrincipalBaseUnsafeAccessors.RefTypeList(entity) = value); + refTypeList.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, List value) => PrincipalBaseUnsafeAccessors.RefTypeList(entity) = value); + refTypeList.SetAccessors( + List (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + List (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeList, 10), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeList), + object (ValueBuffer valueBuffer) => valueBuffer[10]); + refTypeList.SetPropertyIndexes( + index: 10, + originalValueIndex: 10, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); refTypeList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v)), + comparer: new ListOfReferenceTypesComparer, IPAddress>(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer, IPAddress>(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, IPAddress>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, IPAddress>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, IPAddress>( + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, IPAddress>( new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)))), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), elementMapping: MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), keyComparer: new ValueComparer( - (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), - (IPAddress v) => v.GetHashCode(), - (IPAddress v) => v), + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(45)", size: 45), converter: new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v)), + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (IPAddress v) => v.ToString(), - (string v) => IPAddress.Parse(v))))); + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); refTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var stringWithCharSet = runtimeEntityType.AddProperty( @@ -433,30 +666,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueConverter: new CastingConverter(), valueComparer: new CompiledModelTestBase.CustomValueComparer(), providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + stringWithCharSet.SetAccessors( + string (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(11) ? entry.ReadStoreGeneratedValue(3) : (entry.FlaggedAsTemporary(11) && entry.ReadShadowValue(1) == null ? entry.ReadTemporaryValue(3) : entry.ReadShadowValue(1))), + string (InternalEntityEntry entry) => entry.ReadShadowValue(1), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringWithCharSet, 11), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringWithCharSet), + object (ValueBuffer valueBuffer) => valueBuffer[11]); + stringWithCharSet.SetPropertyIndexes( + index: 11, + originalValueIndex: 11, + shadowIndex: 1, + relationshipIndex: -1, + storeGenerationIndex: 3); stringWithCharSet.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(128)", size: 128), converter: new ValueConverter( - (string v) => (string)v, - (string v) => (string)v), + string (string v) => ((string)(v)), + string (string v) => ((string)(v))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (string v) => (string)v, - (string v) => (string)v))); + string (string v) => ((string)(v)), + string (string v) => ((string)(v))))); stringWithCharSet.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); stringWithCharSet.AddAnnotation("Relational:ColumnType", "varchar(128)"); stringWithCharSet.AddAnnotation("Relational:DefaultValue", "String having charset"); @@ -469,30 +714,42 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueConverter: new CastingConverter(), valueComparer: new CompiledModelTestBase.CustomValueComparer(), providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + stringWithCollation.SetAccessors( + string (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(12) ? entry.ReadStoreGeneratedValue(4) : (entry.FlaggedAsTemporary(12) && entry.ReadShadowValue(2) == null ? entry.ReadTemporaryValue(4) : entry.ReadShadowValue(2))), + string (InternalEntityEntry entry) => entry.ReadShadowValue(2), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(stringWithCollation, 12), + string (InternalEntityEntry entry) => entry.GetCurrentValue(stringWithCollation), + object (ValueBuffer valueBuffer) => valueBuffer[12]); + stringWithCollation.SetPropertyIndexes( + index: 12, + originalValueIndex: 12, + shadowIndex: 2, + relationshipIndex: -1, + storeGenerationIndex: 4); stringWithCollation.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar(128)", size: 128), converter: new ValueConverter( - (string v) => (string)v, - (string v) => (string)v), + string (string v) => ((string)(v)), + string (string v) => ((string)(v))), jsonValueReaderWriter: new JsonConvertedValueReaderWriter( JsonStringReaderWriter.Instance, new ValueConverter( - (string v) => (string)v, - (string v) => (string)v))); + string (string v) => ((string)(v)), + string (string v) => ((string)(v))))); stringWithCollation.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); stringWithCollation.AddAnnotation("Relational:ColumnType", "varchar(128)"); stringWithCollation.AddAnnotation("Relational:DefaultValue", "String using collation"); @@ -503,39 +760,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + valueTypeArray.SetGetter( + DateTime[] (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeArray(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeArray(entity) == null, + DateTime[] (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeArray(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeArray(instance) == null); + valueTypeArray.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, DateTime[] value) => PrincipalBaseUnsafeAccessors.ValueTypeArray(entity) = value); + valueTypeArray.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, DateTime[] value) => PrincipalBaseUnsafeAccessors.ValueTypeArray(entity) = value); + valueTypeArray.SetAccessors( + DateTime[] (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeArray(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeArray(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => entry.ReadOriginalValue(valueTypeArray, 13), + DateTime[] (InternalEntityEntry entry) => entry.GetCurrentValue(valueTypeArray), + object (ValueBuffer valueBuffer) => valueBuffer[13]); + valueTypeArray.SetPropertyIndexes( + index: 13, + originalValueIndex: 13, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v)), + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( JsonDateTimeReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( JsonDateTimeReaderWriter.Instance), elementMapping: MySqlDateTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), keyComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), providerValueComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "datetime(6)", precision: 6))); @@ -547,39 +825,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + valueTypeEnumerable.SetGetter( + IEnumerable (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(entity) == null, + IEnumerable (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(instance) == null); + valueTypeEnumerable.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IEnumerable value) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(entity) = value); + valueTypeEnumerable.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IEnumerable value) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(entity) = value); + valueTypeEnumerable.SetAccessors( + IEnumerable (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeEnumerable, 14), + IEnumerable (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeEnumerable), + object (ValueBuffer valueBuffer) => valueBuffer[14]); + valueTypeEnumerable.SetPropertyIndexes( + index: 14, + originalValueIndex: 14, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeEnumerable.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), + comparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + keyComparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, byte>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, byte>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), keyComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v))); + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))); valueTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var valueTypeIList = runtimeEntityType.AddProperty( @@ -588,39 +887,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + valueTypeIList.SetGetter( + IList (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeIList(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeIList(entity) == null, + IList (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeIList(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeIList(instance) == null); + valueTypeIList.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IList value) => PrincipalBaseUnsafeAccessors.ValueTypeIList(entity) = value); + valueTypeIList.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IList value) => PrincipalBaseUnsafeAccessors.ValueTypeIList(entity) = value); + valueTypeIList.SetAccessors( + IList (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeIList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IList (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeIList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IList (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeIList, 15), + IList (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeIList), + object (ValueBuffer valueBuffer) => valueBuffer[15]); + valueTypeIList.SetPropertyIndexes( + index: 15, + originalValueIndex: 15, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeIList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v)), + comparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + keyComparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, byte>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, byte>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, byte>( JsonByteReaderWriter.Instance), elementMapping: MySqlByteTypeMapping.Default.Clone( comparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), keyComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v), + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), providerValueComparer: new ValueComparer( - (byte v1, byte v2) => v1 == v2, - (byte v) => (int)v, - (byte v) => v))); + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))); valueTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var valueTypeList = runtimeEntityType.AddProperty( @@ -629,39 +949,60 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + valueTypeList.SetGetter( + List (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeList(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeList(entity) == null, + List (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeList(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeList(instance) == null); + valueTypeList.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, List value) => PrincipalBaseUnsafeAccessors.ValueTypeList(entity) = value); + valueTypeList.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, List value) => PrincipalBaseUnsafeAccessors.ValueTypeList(entity) = value); + valueTypeList.SetAccessors( + List (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + List (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeList, 16), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeList), + object (ValueBuffer valueBuffer) => valueBuffer[16]); + valueTypeList.SetPropertyIndexes( + index: 16, + originalValueIndex: 16, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); valueTypeList.TypeMapping = MySqlStringTypeMapping.Default.Clone( - comparer: new ListComparer(new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v)), - keyComparer: new ListComparer(new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v)), + comparer: new ListOfValueTypesComparer, short>(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), + keyComparer: new ListOfValueTypesComparer, short>(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), - converter: new CollectionToJsonStringConverter(new JsonCollectionReaderWriter, List, short>( + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, short>( JsonInt16ReaderWriter.Instance)), storeTypePostfix: StoreTypePostfix.None, - jsonValueReaderWriter: new JsonCollectionReaderWriter, List, short>( + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, short>( JsonInt16ReaderWriter.Instance), elementMapping: MySqlShortTypeMapping.Default.Clone( comparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), keyComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v), + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), providerValueComparer: new ValueComparer( - (short v1, short v2) => v1 == v2, - (short v) => (int)v, - (short v) => v))); + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v))); valueTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var key = runtimeEntityType.AddKey( @@ -700,11 +1041,90 @@ public static RuntimeSkipNavigation CreateSkipNavigation1(RuntimeEntityType decl inverse.Inverse = skipNavigation; } + skipNavigation.SetGetter( + ICollection (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Deriveds(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Deriveds(entity) == null, + ICollection (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Deriveds(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Deriveds(instance) == null); + skipNavigation.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, ICollection value) => PrincipalBaseUnsafeAccessors.Deriveds(entity) = value); + skipNavigation.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, ICollection value) => PrincipalBaseUnsafeAccessors.Deriveds(entity) = value); + skipNavigation.SetAccessors( + ICollection (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Deriveds(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + ICollection (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Deriveds(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + null, + ICollection (InternalEntityEntry entry) => entry.GetCurrentValue>(skipNavigation), + null); + skipNavigation.SetPropertyIndexes( + index: 1, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 3, + storeGenerationIndex: -1); + skipNavigation.SetCollectionAccessor, CompiledModelTestBase.PrincipalBase>( + ICollection (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Deriveds(entity), + (CompiledModelTestBase.PrincipalBase entity, ICollection collection) => PrincipalBaseUnsafeAccessors.Deriveds(entity) = ((ICollection)(collection)), + (CompiledModelTestBase.PrincipalBase entity, ICollection collection) => PrincipalBaseUnsafeAccessors.Deriveds(entity) = ((ICollection)(collection)), + ICollection (CompiledModelTestBase.PrincipalBase entity, Action> setter) => ClrCollectionAccessorFactory.CreateAndSetHashSet, CompiledModelTestBase.PrincipalBase>(entity, setter), + ICollection () => ((ICollection)(((ICollection)(new HashSet(ReferenceEqualityComparer.Instance)))))); return skipNavigation; } public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var id = runtimeEntityType.FindProperty("Id"); + var alternateId = runtimeEntityType.FindProperty("AlternateId"); + var enum1 = runtimeEntityType.FindProperty("Enum1"); + var enum2 = runtimeEntityType.FindProperty("Enum2"); + var flagsEnum1 = runtimeEntityType.FindProperty("FlagsEnum1"); + var flagsEnum2 = runtimeEntityType.FindProperty("FlagsEnum2"); + var point = runtimeEntityType.FindProperty("Point"); + var refTypeArray = runtimeEntityType.FindProperty("RefTypeArray"); + var refTypeEnumerable = runtimeEntityType.FindProperty("RefTypeEnumerable"); + var refTypeIList = runtimeEntityType.FindProperty("RefTypeIList"); + var refTypeList = runtimeEntityType.FindProperty("RefTypeList"); + var stringWithCharSet = runtimeEntityType.FindProperty("StringWithCharSet"); + var stringWithCollation = runtimeEntityType.FindProperty("StringWithCollation"); + var valueTypeArray = runtimeEntityType.FindProperty("ValueTypeArray"); + var valueTypeEnumerable = runtimeEntityType.FindProperty("ValueTypeEnumerable"); + var valueTypeIList = runtimeEntityType.FindProperty("ValueTypeIList"); + var valueTypeList = runtimeEntityType.FindProperty("ValueTypeList"); + var key = runtimeEntityType.FindKey(new[] { id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateSimpleNullableFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory(key)); + var key0 = runtimeEntityType.FindKey(new[] { id, alternateId }); + key0.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateCompositeFactory(key0)); + key0.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory>(key0)); + var owned = runtimeEntityType.FindNavigation("Owned"); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.PrincipalBase)(source.Entity)); + return ((ISnapshot)(new Snapshot, IList, List, string, string, DateTime[], IEnumerable, IList, List>((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id))), ((ValueComparer)(((IProperty)alternateId).GetValueComparer())).Snapshot(source.GetCurrentValue(alternateId)), ((ValueComparer)(((IProperty)enum1).GetValueComparer())).Snapshot(source.GetCurrentValue(enum1)), (source.GetCurrentValue(enum2) == null ? null : ((ValueComparer)(((IProperty)enum2).GetValueComparer())).Snapshot(source.GetCurrentValue(enum2))), ((ValueComparer)(((IProperty)flagsEnum1).GetValueComparer())).Snapshot(source.GetCurrentValue(flagsEnum1)), ((ValueComparer)(((IProperty)flagsEnum2).GetValueComparer())).Snapshot(source.GetCurrentValue(flagsEnum2)), (source.GetCurrentValue(point) == null ? null : ((ValueComparer)(((IProperty)point).GetValueComparer())).Snapshot(source.GetCurrentValue(point))), (((object)(source.GetCurrentValue(refTypeArray))) == null ? null : ((IPAddress[])(((ValueComparer)(((IProperty)refTypeArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(refTypeArray))))))), (((object)(source.GetCurrentValue>(refTypeEnumerable))) == null ? null : ((IEnumerable)(((ValueComparer)(((IProperty)refTypeEnumerable).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeEnumerable))))))), (((object)(source.GetCurrentValue>(refTypeIList))) == null ? null : ((IList)(((ValueComparer)(((IProperty)refTypeIList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeIList))))))), (((object)(source.GetCurrentValue>(refTypeList))) == null ? null : ((List)(((ValueComparer)(((IProperty)refTypeList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeList))))))), (source.GetCurrentValue(stringWithCharSet) == null ? null : ((ValueComparer)(((IProperty)stringWithCharSet).GetValueComparer())).Snapshot(source.GetCurrentValue(stringWithCharSet))), (source.GetCurrentValue(stringWithCollation) == null ? null : ((ValueComparer)(((IProperty)stringWithCollation).GetValueComparer())).Snapshot(source.GetCurrentValue(stringWithCollation))), (((IEnumerable)(source.GetCurrentValue(valueTypeArray))) == null ? null : ((DateTime[])(((ValueComparer>)(((IProperty)valueTypeArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(valueTypeArray))))))), (source.GetCurrentValue>(valueTypeEnumerable) == null ? null : ((ValueComparer>)(((IProperty)valueTypeEnumerable).GetValueComparer())).Snapshot(source.GetCurrentValue>(valueTypeEnumerable))), (((IEnumerable)(source.GetCurrentValue>(valueTypeIList))) == null ? null : ((IList)(((ValueComparer>)(((IProperty)valueTypeIList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeIList))))))), (((IEnumerable)(source.GetCurrentValue>(valueTypeList))) == null ? null : ((List)(((ValueComparer>)(((IProperty)valueTypeList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeList)))))))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot((default(long? ) == null ? null : ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(default(long? ))), ((ValueComparer)(((IProperty)alternateId).GetValueComparer())).Snapshot(default(Guid)), (default(Point) == null ? null : ((ValueComparer)(((IProperty)point).GetValueComparer())).Snapshot(default(Point))), (default(string) == null ? null : ((ValueComparer)(((IProperty)stringWithCharSet).GetValueComparer())).Snapshot(default(string))), (default(string) == null ? null : ((ValueComparer)(((IProperty)stringWithCollation).GetValueComparer())).Snapshot(default(string))))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(long? ), default(Guid), default(Point), default(string), default(string))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("Point") ? ((Point)(source["Point"])) : null), (source.ContainsKey("StringWithCharSet") ? ((string)(source["StringWithCharSet"])) : null), (source.ContainsKey("StringWithCollation") ? ((string)(source["StringWithCollation"])) : null))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(Point), default(string), default(string))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.PrincipalBase)(source.Entity)); + return ((ISnapshot)(new Snapshot((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))), ((ValueComparer)(((IProperty)alternateId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(alternateId)), PrincipalBaseUnsafeAccessors._ownedField(entity7), (object)(null)))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 17, + navigationCount: 2, + complexPropertyCount: 0, + originalValueCount: 17, + shadowCount: 3, + relationshipCount: 4, + storeGeneratedCount: 5); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:MappingStrategy", "TPT"); runtimeEntityType.AddAnnotation("Relational:Schema", "mySchema"); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBasePrincipalDerivedDependentBasebyteEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBasePrincipalDerivedDependentBasebyteEntityType.cs index 4109d565b..22ede5287 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBasePrincipalDerivedDependentBasebyteEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBasePrincipalDerivedDependentBasebyteEntityType.cs @@ -6,7 +6,10 @@ using System.Reflection; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Storage; using Microsoft.EntityFrameworkCore.Storage.ValueConversion; using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; @@ -16,7 +19,8 @@ namespace TestNamespace { - internal partial class PrincipalBasePrincipalDerivedDependentBasebyteEntityType + [EntityFrameworkInternal] + public partial class PrincipalBasePrincipalDerivedDependentBasebyteEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -37,19 +41,65 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(long), propertyInfo: runtimeEntityType.FindIndexerPropertyInfo(), afterSaveBehavior: PropertySaveBehavior.Throw); + derivedsId.SetGetter( + long (Dictionary entity) => ((((IDictionary)entity).ContainsKey("DerivedsId") ? entity["DerivedsId"] : null) == null ? 0L : ((long)((((IDictionary)entity).ContainsKey("DerivedsId") ? entity["DerivedsId"] : null)))), + bool (Dictionary entity) => (((IDictionary)entity).ContainsKey("DerivedsId") ? entity["DerivedsId"] : null) == null, + long (Dictionary instance) => ((((IDictionary)instance).ContainsKey("DerivedsId") ? instance["DerivedsId"] : null) == null ? 0L : ((long)((((IDictionary)instance).ContainsKey("DerivedsId") ? instance["DerivedsId"] : null)))), + bool (Dictionary instance) => (((IDictionary)instance).ContainsKey("DerivedsId") ? instance["DerivedsId"] : null) == null); + derivedsId.SetSetter( + (Dictionary entity, long value) => entity["DerivedsId"] = ((object)(value))); + derivedsId.SetMaterializationSetter( + (Dictionary entity, long value) => entity["DerivedsId"] = ((object)(value))); + derivedsId.SetAccessors( + long (InternalEntityEntry entry) => + { + if (entry.FlaggedAsStoreGenerated(0)) + { + return entry.ReadStoreGeneratedValue(0); + } + else + { + { + if (entry.FlaggedAsTemporary(0) && (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("DerivedsId") ? ((Dictionary)(entry.Entity))["DerivedsId"] : null) == null) + { + return entry.ReadTemporaryValue(0); + } + else + { + var nullableValue = (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("DerivedsId") ? ((Dictionary)(entry.Entity))["DerivedsId"] : null); + return (nullableValue == null ? default(long) : ((long)(nullableValue))); + } + } + } + }, + long (InternalEntityEntry entry) => + { + var nullableValue = (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("DerivedsId") ? ((Dictionary)(entry.Entity))["DerivedsId"] : null); + return (nullableValue == null ? default(long) : ((long)(nullableValue))); + }, + long (InternalEntityEntry entry) => entry.ReadOriginalValue(derivedsId, 0), + long (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(derivedsId, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + derivedsId.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: -1, + relationshipIndex: 0, + storeGenerationIndex: 0); derivedsId.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), keyComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v)); + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + derivedsId.SetCurrentValueComparer(new EntryCurrentValueComparer(derivedsId)); derivedsId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var derivedsAlternateId = runtimeEntityType.AddProperty( @@ -57,19 +107,65 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(Guid), propertyInfo: runtimeEntityType.FindIndexerPropertyInfo(), afterSaveBehavior: PropertySaveBehavior.Throw); + derivedsAlternateId.SetGetter( + Guid (Dictionary entity) => ((((IDictionary)entity).ContainsKey("DerivedsAlternateId") ? entity["DerivedsAlternateId"] : null) == null ? new Guid("00000000-0000-0000-0000-000000000000") : ((Guid)((((IDictionary)entity).ContainsKey("DerivedsAlternateId") ? entity["DerivedsAlternateId"] : null)))), + bool (Dictionary entity) => (((IDictionary)entity).ContainsKey("DerivedsAlternateId") ? entity["DerivedsAlternateId"] : null) == null, + Guid (Dictionary instance) => ((((IDictionary)instance).ContainsKey("DerivedsAlternateId") ? instance["DerivedsAlternateId"] : null) == null ? new Guid("00000000-0000-0000-0000-000000000000") : ((Guid)((((IDictionary)instance).ContainsKey("DerivedsAlternateId") ? instance["DerivedsAlternateId"] : null)))), + bool (Dictionary instance) => (((IDictionary)instance).ContainsKey("DerivedsAlternateId") ? instance["DerivedsAlternateId"] : null) == null); + derivedsAlternateId.SetSetter( + (Dictionary entity, Guid value) => entity["DerivedsAlternateId"] = ((object)(value))); + derivedsAlternateId.SetMaterializationSetter( + (Dictionary entity, Guid value) => entity["DerivedsAlternateId"] = ((object)(value))); + derivedsAlternateId.SetAccessors( + Guid (InternalEntityEntry entry) => + { + if (entry.FlaggedAsStoreGenerated(1)) + { + return entry.ReadStoreGeneratedValue(1); + } + else + { + { + if (entry.FlaggedAsTemporary(1) && (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("DerivedsAlternateId") ? ((Dictionary)(entry.Entity))["DerivedsAlternateId"] : null) == null) + { + return entry.ReadTemporaryValue(1); + } + else + { + var nullableValue = (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("DerivedsAlternateId") ? ((Dictionary)(entry.Entity))["DerivedsAlternateId"] : null); + return (nullableValue == null ? default(Guid) : ((Guid)(nullableValue))); + } + } + } + }, + Guid (InternalEntityEntry entry) => + { + var nullableValue = (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("DerivedsAlternateId") ? ((Dictionary)(entry.Entity))["DerivedsAlternateId"] : null); + return (nullableValue == null ? default(Guid) : ((Guid)(nullableValue))); + }, + Guid (InternalEntityEntry entry) => entry.ReadOriginalValue(derivedsAlternateId, 1), + Guid (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(derivedsAlternateId, 1), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + derivedsAlternateId.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: -1, + relationshipIndex: 1, + storeGenerationIndex: 1); derivedsAlternateId.TypeMapping = MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v)); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)); + derivedsAlternateId.SetCurrentValueComparer(new EntryCurrentValueComparer(derivedsAlternateId)); derivedsAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var principalsId = runtimeEntityType.AddProperty( @@ -77,19 +173,65 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(long), propertyInfo: runtimeEntityType.FindIndexerPropertyInfo(), afterSaveBehavior: PropertySaveBehavior.Throw); + principalsId.SetGetter( + long (Dictionary entity) => ((((IDictionary)entity).ContainsKey("PrincipalsId") ? entity["PrincipalsId"] : null) == null ? 0L : ((long)((((IDictionary)entity).ContainsKey("PrincipalsId") ? entity["PrincipalsId"] : null)))), + bool (Dictionary entity) => (((IDictionary)entity).ContainsKey("PrincipalsId") ? entity["PrincipalsId"] : null) == null, + long (Dictionary instance) => ((((IDictionary)instance).ContainsKey("PrincipalsId") ? instance["PrincipalsId"] : null) == null ? 0L : ((long)((((IDictionary)instance).ContainsKey("PrincipalsId") ? instance["PrincipalsId"] : null)))), + bool (Dictionary instance) => (((IDictionary)instance).ContainsKey("PrincipalsId") ? instance["PrincipalsId"] : null) == null); + principalsId.SetSetter( + (Dictionary entity, long value) => entity["PrincipalsId"] = ((object)(value))); + principalsId.SetMaterializationSetter( + (Dictionary entity, long value) => entity["PrincipalsId"] = ((object)(value))); + principalsId.SetAccessors( + long (InternalEntityEntry entry) => + { + if (entry.FlaggedAsStoreGenerated(2)) + { + return entry.ReadStoreGeneratedValue(2); + } + else + { + { + if (entry.FlaggedAsTemporary(2) && (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("PrincipalsId") ? ((Dictionary)(entry.Entity))["PrincipalsId"] : null) == null) + { + return entry.ReadTemporaryValue(2); + } + else + { + var nullableValue = (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("PrincipalsId") ? ((Dictionary)(entry.Entity))["PrincipalsId"] : null); + return (nullableValue == null ? default(long) : ((long)(nullableValue))); + } + } + } + }, + long (InternalEntityEntry entry) => + { + var nullableValue = (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("PrincipalsId") ? ((Dictionary)(entry.Entity))["PrincipalsId"] : null); + return (nullableValue == null ? default(long) : ((long)(nullableValue))); + }, + long (InternalEntityEntry entry) => entry.ReadOriginalValue(principalsId, 2), + long (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalsId, 2), + object (ValueBuffer valueBuffer) => valueBuffer[2]); + principalsId.SetPropertyIndexes( + index: 2, + originalValueIndex: 2, + shadowIndex: -1, + relationshipIndex: 2, + storeGenerationIndex: 2); principalsId.TypeMapping = MySqlLongTypeMapping.Default.Clone( comparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), keyComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v), + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), providerValueComparer: new ValueComparer( - (long v1, long v2) => v1 == v2, - (long v) => v.GetHashCode(), - (long v) => v)); + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + principalsId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalsId)); principalsId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var principalsAlternateId = runtimeEntityType.AddProperty( @@ -97,19 +239,65 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(Guid), propertyInfo: runtimeEntityType.FindIndexerPropertyInfo(), afterSaveBehavior: PropertySaveBehavior.Throw); + principalsAlternateId.SetGetter( + Guid (Dictionary entity) => ((((IDictionary)entity).ContainsKey("PrincipalsAlternateId") ? entity["PrincipalsAlternateId"] : null) == null ? new Guid("00000000-0000-0000-0000-000000000000") : ((Guid)((((IDictionary)entity).ContainsKey("PrincipalsAlternateId") ? entity["PrincipalsAlternateId"] : null)))), + bool (Dictionary entity) => (((IDictionary)entity).ContainsKey("PrincipalsAlternateId") ? entity["PrincipalsAlternateId"] : null) == null, + Guid (Dictionary instance) => ((((IDictionary)instance).ContainsKey("PrincipalsAlternateId") ? instance["PrincipalsAlternateId"] : null) == null ? new Guid("00000000-0000-0000-0000-000000000000") : ((Guid)((((IDictionary)instance).ContainsKey("PrincipalsAlternateId") ? instance["PrincipalsAlternateId"] : null)))), + bool (Dictionary instance) => (((IDictionary)instance).ContainsKey("PrincipalsAlternateId") ? instance["PrincipalsAlternateId"] : null) == null); + principalsAlternateId.SetSetter( + (Dictionary entity, Guid value) => entity["PrincipalsAlternateId"] = ((object)(value))); + principalsAlternateId.SetMaterializationSetter( + (Dictionary entity, Guid value) => entity["PrincipalsAlternateId"] = ((object)(value))); + principalsAlternateId.SetAccessors( + Guid (InternalEntityEntry entry) => + { + if (entry.FlaggedAsStoreGenerated(3)) + { + return entry.ReadStoreGeneratedValue(3); + } + else + { + { + if (entry.FlaggedAsTemporary(3) && (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("PrincipalsAlternateId") ? ((Dictionary)(entry.Entity))["PrincipalsAlternateId"] : null) == null) + { + return entry.ReadTemporaryValue(3); + } + else + { + var nullableValue = (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("PrincipalsAlternateId") ? ((Dictionary)(entry.Entity))["PrincipalsAlternateId"] : null); + return (nullableValue == null ? default(Guid) : ((Guid)(nullableValue))); + } + } + } + }, + Guid (InternalEntityEntry entry) => + { + var nullableValue = (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("PrincipalsAlternateId") ? ((Dictionary)(entry.Entity))["PrincipalsAlternateId"] : null); + return (nullableValue == null ? default(Guid) : ((Guid)(nullableValue))); + }, + Guid (InternalEntityEntry entry) => entry.ReadOriginalValue(principalsAlternateId, 3), + Guid (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalsAlternateId, 3), + object (ValueBuffer valueBuffer) => valueBuffer[3]); + principalsAlternateId.SetPropertyIndexes( + index: 3, + originalValueIndex: 3, + shadowIndex: -1, + relationshipIndex: 3, + storeGenerationIndex: 3); principalsAlternateId.TypeMapping = MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v)); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)); + principalsAlternateId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalsAlternateId)); principalsAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var rowid = runtimeEntityType.AddProperty( @@ -121,25 +309,46 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueGenerated: ValueGenerated.OnAddOrUpdate, beforeSaveBehavior: PropertySaveBehavior.Ignore, afterSaveBehavior: PropertySaveBehavior.Ignore); + rowid.SetGetter( + byte[] (Dictionary entity) => ((((IDictionary)entity).ContainsKey("rowid") ? entity["rowid"] : null) == null ? null : ((byte[])((((IDictionary)entity).ContainsKey("rowid") ? entity["rowid"] : null)))), + bool (Dictionary entity) => (((IDictionary)entity).ContainsKey("rowid") ? entity["rowid"] : null) == null, + byte[] (Dictionary instance) => ((((IDictionary)instance).ContainsKey("rowid") ? instance["rowid"] : null) == null ? null : ((byte[])((((IDictionary)instance).ContainsKey("rowid") ? instance["rowid"] : null)))), + bool (Dictionary instance) => (((IDictionary)instance).ContainsKey("rowid") ? instance["rowid"] : null) == null); + rowid.SetSetter( + (Dictionary entity, byte[] value) => entity["rowid"] = ((object)(value))); + rowid.SetMaterializationSetter( + (Dictionary entity, byte[] value) => entity["rowid"] = ((object)(value))); + rowid.SetAccessors( + byte[] (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(4) ? entry.ReadStoreGeneratedValue(4) : (entry.FlaggedAsTemporary(4) && (((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("rowid") ? ((Dictionary)(entry.Entity))["rowid"] : null) == null ? entry.ReadTemporaryValue(4) : ((byte[])((((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("rowid") ? ((Dictionary)(entry.Entity))["rowid"] : null))))), + byte[] (InternalEntityEntry entry) => ((byte[])((((IDictionary)((Dictionary)(entry.Entity))).ContainsKey("rowid") ? ((Dictionary)(entry.Entity))["rowid"] : null))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(rowid, 4), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(rowid), + object (ValueBuffer valueBuffer) => valueBuffer[4]); + rowid.SetPropertyIndexes( + index: 4, + originalValueIndex: 4, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: 4); rowid.TypeMapping = MySqlDateTimeTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(v1, v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(v), - (Byte[] v) => v == null ? null : v.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(v1, v2), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(v), + byte[] (byte[] v) => (v == null ? null : v.ToArray())), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (DateTime v1, DateTime v2) => v1.Equals(v2), - (DateTime v) => v.GetHashCode(), - (DateTime v) => v), + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "timestamp(6)", precision: 6), converter: new ValueConverter( - (Byte[] v) => BytesToDateTimeConverter.FromBytes(v), - (DateTime v) => BytesToDateTimeConverter.ToBytes(v))); + DateTime (byte[] v) => BytesToDateTimeConverter.FromBytes(v), + byte[] (DateTime v) => BytesToDateTimeConverter.ToBytes(v))); rowid.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var key = runtimeEntityType.AddKey( @@ -177,6 +386,42 @@ public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEnt public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var derivedsId = runtimeEntityType.FindProperty("DerivedsId"); + var derivedsAlternateId = runtimeEntityType.FindProperty("DerivedsAlternateId"); + var principalsId = runtimeEntityType.FindProperty("PrincipalsId"); + var principalsAlternateId = runtimeEntityType.FindProperty("PrincipalsAlternateId"); + var rowid = runtimeEntityType.FindProperty("rowid"); + var key = runtimeEntityType.FindKey(new[] { derivedsId, derivedsAlternateId, principalsId, principalsAlternateId }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateCompositeFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory>(key)); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((Dictionary)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)derivedsId).GetValueComparer())).Snapshot(source.GetCurrentValue(derivedsId)), ((ValueComparer)(((IProperty)derivedsAlternateId).GetValueComparer())).Snapshot(source.GetCurrentValue(derivedsAlternateId)), ((ValueComparer)(((IProperty)principalsId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalsId)), ((ValueComparer)(((IProperty)principalsAlternateId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalsAlternateId)), (source.GetCurrentValue(rowid) == null ? null : ((ValueComparer)(((IProperty)rowid).GetValueComparer())).Snapshot(source.GetCurrentValue(rowid)))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)derivedsId).GetValueComparer())).Snapshot(default(long)), ((ValueComparer)(((IProperty)derivedsAlternateId).GetValueComparer())).Snapshot(default(Guid)), ((ValueComparer)(((IProperty)principalsId).GetValueComparer())).Snapshot(default(long)), ((ValueComparer)(((IProperty)principalsAlternateId).GetValueComparer())).Snapshot(default(Guid)), (default(byte[]) == null ? null : ((ValueComparer)(((IProperty)rowid).GetValueComparer())).Snapshot(default(byte[]))))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(long), default(Guid), default(long), default(Guid), default(byte[]))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => Snapshot.Empty); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => Snapshot.Empty); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((Dictionary)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)derivedsId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(derivedsId)), ((ValueComparer)(((IProperty)derivedsAlternateId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(derivedsAlternateId)), ((ValueComparer)(((IProperty)principalsId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalsId)), ((ValueComparer)(((IProperty)principalsAlternateId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalsAlternateId))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 5, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 5, + shadowCount: 0, + relationshipCount: 4, + storeGeneratedCount: 5); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBaseUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBaseUnsafeAccessors.cs new file mode 100644 index 000000000..4b43c6dd1 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalBaseUnsafeAccessors.cs @@ -0,0 +1,63 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class PrincipalBaseUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref long? Id(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.AnEnum Enum1(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.AnEnum? Enum2(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.AFlagsEnum FlagsEnum1(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "get_FlagsEnum2")] + public static extern CompiledModelTestBase.AFlagsEnum Get_FlagsEnum2(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Method, Name = "set_FlagsEnum2")] + public static extern void Set_FlagsEnum2(CompiledModelTestBase.PrincipalBase @this, CompiledModelTestBase.AFlagsEnum value); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IPAddress[] RefTypeArray(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IEnumerable RefTypeEnumerable(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IList RefTypeIList(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List RefTypeList(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTime[] ValueTypeArray(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IEnumerable ValueTypeEnumerable(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IList ValueTypeIList(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List ValueTypeList(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_ownedField")] + public static extern ref CompiledModelTestBase.OwnedType _ownedField(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ICollection Deriveds(CompiledModelTestBase.PrincipalBase @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalDerivedEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalDerivedEntityType.cs index 4c3ed5ed5..de9b34c38 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalDerivedEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalDerivedEntityType.cs @@ -1,17 +1,24 @@ // using System; using System.Collections.Generic; +using System.Net; using System.Reflection; using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; +using NetTopologySuite.Geometries; #pragma warning disable 219, 612, 618 #nullable disable namespace TestNamespace { - internal partial class PrincipalDerivedEntityType + [EntityFrameworkInternal] + public partial class PrincipalDerivedEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -53,9 +60,7 @@ public static RuntimeSkipNavigation CreateSkipNavigation1(RuntimeEntityType decl false, typeof(ICollection), propertyInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetProperty("Principals", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), - fieldInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), - eagerLoaded: true, - lazyLoadingEnabled: false); + fieldInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); var inverse = targetEntityType.FindSkipNavigation("Deriveds"); if (inverse != null) @@ -64,11 +69,86 @@ public static RuntimeSkipNavigation CreateSkipNavigation1(RuntimeEntityType decl inverse.Inverse = skipNavigation; } + skipNavigation.SetGetter( + ICollection (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Principals(entity), + bool (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Principals(entity) == null, + ICollection (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.Principals(instance), + bool (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.Principals(instance) == null); + skipNavigation.SetSetter( + (CompiledModelTestBase.PrincipalDerived> entity, ICollection value) => PrincipalDerivedUnsafeAccessors>.Principals(entity) = value); + skipNavigation.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalDerived> entity, ICollection value) => PrincipalDerivedUnsafeAccessors>.Principals(entity) = value); + skipNavigation.SetAccessors( + ICollection (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.Principals(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + ICollection (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.Principals(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + null, + ICollection (InternalEntityEntry entry) => entry.GetCurrentValue>(skipNavigation), + null); + skipNavigation.SetPropertyIndexes( + index: 4, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 6, + storeGenerationIndex: -1); + skipNavigation.SetCollectionAccessor>, ICollection, CompiledModelTestBase.PrincipalBase>( + ICollection (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Principals(entity), + (CompiledModelTestBase.PrincipalDerived> entity, ICollection collection) => PrincipalDerivedUnsafeAccessors>.Principals(entity) = ((ICollection)(collection)), + (CompiledModelTestBase.PrincipalDerived> entity, ICollection collection) => PrincipalDerivedUnsafeAccessors>.Principals(entity) = ((ICollection)(collection)), + ICollection (CompiledModelTestBase.PrincipalDerived> entity, Action>, ICollection> setter) => ClrCollectionAccessorFactory.CreateAndSetHashSet>, ICollection, CompiledModelTestBase.PrincipalBase>(entity, setter), + ICollection () => ((ICollection)(((ICollection)(new HashSet(ReferenceEqualityComparer.Instance)))))); return skipNavigation; } public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var id = runtimeEntityType.FindProperty("Id"); + var alternateId = runtimeEntityType.FindProperty("AlternateId"); + var enum1 = runtimeEntityType.FindProperty("Enum1"); + var enum2 = runtimeEntityType.FindProperty("Enum2"); + var flagsEnum1 = runtimeEntityType.FindProperty("FlagsEnum1"); + var flagsEnum2 = runtimeEntityType.FindProperty("FlagsEnum2"); + var point = runtimeEntityType.FindProperty("Point"); + var refTypeArray = runtimeEntityType.FindProperty("RefTypeArray"); + var refTypeEnumerable = runtimeEntityType.FindProperty("RefTypeEnumerable"); + var refTypeIList = runtimeEntityType.FindProperty("RefTypeIList"); + var refTypeList = runtimeEntityType.FindProperty("RefTypeList"); + var stringWithCharSet = runtimeEntityType.FindProperty("StringWithCharSet"); + var stringWithCollation = runtimeEntityType.FindProperty("StringWithCollation"); + var valueTypeArray = runtimeEntityType.FindProperty("ValueTypeArray"); + var valueTypeEnumerable = runtimeEntityType.FindProperty("ValueTypeEnumerable"); + var valueTypeIList = runtimeEntityType.FindProperty("ValueTypeIList"); + var valueTypeList = runtimeEntityType.FindProperty("ValueTypeList"); + var owned = runtimeEntityType.FindNavigation("Owned"); + var dependent = runtimeEntityType.FindNavigation("Dependent"); + var manyOwned = runtimeEntityType.FindNavigation("ManyOwned"); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.PrincipalDerived>)(source.Entity)); + return ((ISnapshot)(new Snapshot, IList, List, string, string, DateTime[], IEnumerable, IList, List>((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id))), ((ValueComparer)(((IProperty)alternateId).GetValueComparer())).Snapshot(source.GetCurrentValue(alternateId)), ((ValueComparer)(((IProperty)enum1).GetValueComparer())).Snapshot(source.GetCurrentValue(enum1)), (source.GetCurrentValue(enum2) == null ? null : ((ValueComparer)(((IProperty)enum2).GetValueComparer())).Snapshot(source.GetCurrentValue(enum2))), ((ValueComparer)(((IProperty)flagsEnum1).GetValueComparer())).Snapshot(source.GetCurrentValue(flagsEnum1)), ((ValueComparer)(((IProperty)flagsEnum2).GetValueComparer())).Snapshot(source.GetCurrentValue(flagsEnum2)), (source.GetCurrentValue(point) == null ? null : ((ValueComparer)(((IProperty)point).GetValueComparer())).Snapshot(source.GetCurrentValue(point))), (((object)(source.GetCurrentValue(refTypeArray))) == null ? null : ((IPAddress[])(((ValueComparer)(((IProperty)refTypeArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(refTypeArray))))))), (((object)(source.GetCurrentValue>(refTypeEnumerable))) == null ? null : ((IEnumerable)(((ValueComparer)(((IProperty)refTypeEnumerable).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeEnumerable))))))), (((object)(source.GetCurrentValue>(refTypeIList))) == null ? null : ((IList)(((ValueComparer)(((IProperty)refTypeIList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeIList))))))), (((object)(source.GetCurrentValue>(refTypeList))) == null ? null : ((List)(((ValueComparer)(((IProperty)refTypeList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeList))))))), (source.GetCurrentValue(stringWithCharSet) == null ? null : ((ValueComparer)(((IProperty)stringWithCharSet).GetValueComparer())).Snapshot(source.GetCurrentValue(stringWithCharSet))), (source.GetCurrentValue(stringWithCollation) == null ? null : ((ValueComparer)(((IProperty)stringWithCollation).GetValueComparer())).Snapshot(source.GetCurrentValue(stringWithCollation))), (((IEnumerable)(source.GetCurrentValue(valueTypeArray))) == null ? null : ((DateTime[])(((ValueComparer>)(((IProperty)valueTypeArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(valueTypeArray))))))), (source.GetCurrentValue>(valueTypeEnumerable) == null ? null : ((ValueComparer>)(((IProperty)valueTypeEnumerable).GetValueComparer())).Snapshot(source.GetCurrentValue>(valueTypeEnumerable))), (((IEnumerable)(source.GetCurrentValue>(valueTypeIList))) == null ? null : ((IList)(((ValueComparer>)(((IProperty)valueTypeIList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeIList))))))), (((IEnumerable)(source.GetCurrentValue>(valueTypeList))) == null ? null : ((List)(((ValueComparer>)(((IProperty)valueTypeList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeList)))))))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot((default(long? ) == null ? null : ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(default(long? ))), ((ValueComparer)(((IProperty)alternateId).GetValueComparer())).Snapshot(default(Guid)), (default(Point) == null ? null : ((ValueComparer)(((IProperty)point).GetValueComparer())).Snapshot(default(Point))), (default(string) == null ? null : ((ValueComparer)(((IProperty)stringWithCharSet).GetValueComparer())).Snapshot(default(string))), (default(string) == null ? null : ((ValueComparer)(((IProperty)stringWithCollation).GetValueComparer())).Snapshot(default(string))))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(long? ), default(Guid), default(Point), default(string), default(string))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("Point") ? ((Point)(source["Point"])) : null), (source.ContainsKey("StringWithCharSet") ? ((string)(source["StringWithCharSet"])) : null), (source.ContainsKey("StringWithCollation") ? ((string)(source["StringWithCollation"])) : null))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(Point), default(string), default(string))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity7 = ((CompiledModelTestBase.PrincipalDerived>)(source.Entity)); + return ((ISnapshot)(new Snapshot((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))), ((ValueComparer)(((IProperty)alternateId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(alternateId)), PrincipalBaseUnsafeAccessors._ownedField(entity7), (object)(null), PrincipalDerivedUnsafeAccessors>.Dependent(entity7), SnapshotFactoryFactory.SnapshotCollection(PrincipalDerivedUnsafeAccessors>.ManyOwned(entity7)), (object)(null)))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 17, + navigationCount: 5, + complexPropertyCount: 0, + originalValueCount: 17, + shadowCount: 3, + relationshipCount: 7, + storeGeneratedCount: 5); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalDerivedUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalDerivedUnsafeAccessors.cs new file mode 100644 index 000000000..924e4c826 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/BigModel/PrincipalDerivedUnsafeAccessors.cs @@ -0,0 +1,23 @@ +// +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class PrincipalDerivedUnsafeAccessors + where TDependent : class + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TDependent Dependent(CompiledModelTestBase.PrincipalDerived @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "ManyOwned")] + public static extern ref ICollection ManyOwned(CompiledModelTestBase.PrincipalDerived @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ICollection Principals(CompiledModelTestBase.PrincipalDerived @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DataEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DataEntityType.cs index e4ea3b2fa..6771fc2c4 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DataEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DataEntityType.cs @@ -1,11 +1,16 @@ // using System; using System.Collections; +using System.Collections.Generic; using System.Linq; using System.Reflection; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage; using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; #pragma warning disable 219, 612, 618 @@ -13,7 +18,8 @@ namespace TestNamespace { - internal partial class DataEntityType + [EntityFrameworkInternal] + public partial class DataEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -30,19 +36,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueGenerated: ValueGenerated.OnAdd, afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: 0); + id.SetAccessors( + int (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(0) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(0) && entry.ReadShadowValue(0) == 0 ? entry.ReadTemporaryValue(0) : entry.ReadShadowValue(0))), + int (InternalEntityEntry entry) => entry.ReadShadowValue(0), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 0), + int (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + id.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: 0, + relationshipIndex: 0, + storeGenerationIndex: 0); id.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); + id.SetCurrentValueComparer(new EntryCurrentValueComparer(id)); id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); var blob = runtimeEntityType.AddProperty( @@ -51,19 +70,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.Data).GetProperty("Blob", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.Data).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + blob.SetGetter( + byte[] (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity), + bool (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity) == null, + byte[] (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance), + bool (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance) == null); + blob.SetSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetMaterializationSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetAccessors( + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(blob, 1), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(blob), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + blob.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); blob.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray())); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray())); blob.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var key = runtimeEntityType.AddKey( @@ -75,6 +115,39 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var id = runtimeEntityType.FindProperty("Id"); + var blob = runtimeEntityType.FindProperty("Blob"); + var key = runtimeEntityType.FindKey(new[] { id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateSimpleNonNullableFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory(key)); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.Data)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id)), (source.GetCurrentValue(blob) == null ? null : ((ValueComparer)(((IProperty)blob).GetValueComparer())).Snapshot(source.GetCurrentValue(blob)))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(default(int)))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(int))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("Id") ? ((int)(source["Id"])) : 0))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(int))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.Data)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 2, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 2, + shadowCount: 1, + relationshipCount: 1, + storeGeneratedCount: 1); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DataUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DataUnsafeAccessors.cs new file mode 100644 index 000000000..193c89702 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DataUnsafeAccessors.cs @@ -0,0 +1,16 @@ +// +using System; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DataUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[] Blob(CompiledModelTestBase.Data @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DbContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DbContextAssemblyAttributes.cs new file mode 100644 index 000000000..c224873f6 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DbContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(DbContext), typeof(DbContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DbContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DbContextModelBuilder.cs index 8b735b26a..01ee5202f 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DbContextModelBuilder.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/CheckConstraints/DbContextModelBuilder.cs @@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; using Microsoft.EntityFrameworkCore.Metadata.Internal; +using Microsoft.EntityFrameworkCore.Update.Internal; #pragma warning disable 219, 612, 618 #nullable disable @@ -26,7 +27,7 @@ partial void Initialize() AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); AddAnnotation("Relational:MaxIdentifierLength", 64); - AddRuntimeAnnotation("Relational:RelationalModel", CreateRelationalModel()); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); } private IRelationalModel CreateRelationalModel() @@ -57,25 +58,28 @@ private IRelationalModel CreateRelationalModel() var dataTable = new Table("Data", null, relationalModel); var idColumn = new Column("Id", "int", dataTable); dataTable.Columns.Add("Id", idColumn); + idColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn); var blobColumn = new Column("Blob", "longblob", dataTable) { IsNullable = true }; dataTable.Columns.Add("Blob", blobColumn); - var pK_Data = new UniqueConstraint("PK_Data", dataTable, new[] { idColumn }); - dataTable.PrimaryKey = pK_Data; - var pK_DataUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", - new[] { "Id" }); - pK_Data.MappedKeys.Add(pK_DataUc); - RelationalModel.GetOrCreateUniqueConstraints(pK_DataUc).Add(pK_Data); - dataTable.UniqueConstraints.Add("PK_Data", pK_Data); + blobColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(blobColumn); relationalModel.Tables.Add(("Data", null), dataTable); var dataTableMapping = new TableMapping(data, dataTable, null); dataTable.AddTypeMapping(dataTableMapping, false); tableMappings.Add(dataTableMapping); RelationalModel.CreateColumnMapping(idColumn, data.FindProperty("Id")!, dataTableMapping); RelationalModel.CreateColumnMapping(blobColumn, data.FindProperty("Blob")!, dataTableMapping); + var pK_Data = new UniqueConstraint("PK_Data", dataTable, new[] { idColumn }); + dataTable.PrimaryKey = pK_Data; + pK_Data.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(pK_Data)); + var pK_DataKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", + new[] { "Id" }); + pK_Data.MappedKeys.Add(pK_DataKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_DataKey).Add(pK_Data); + dataTable.UniqueConstraints.Add("PK_Data", pK_Data); return relationalModel.MakeReadOnly(); } } diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_parameter_type_mapping/FunctionParameterTypeMappingContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_parameter_type_mapping/FunctionParameterTypeMappingContextAssemblyAttributes.cs new file mode 100644 index 000000000..188db7938 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_parameter_type_mapping/FunctionParameterTypeMappingContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Scaffolding; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(CompiledModelRelationalTestBase.FunctionParameterTypeMappingContext), typeof(FunctionParameterTypeMappingContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_parameter_type_mapping/FunctionParameterTypeMappingContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_parameter_type_mapping/FunctionParameterTypeMappingContextModelBuilder.cs index 5c77a9ee3..38e8425cc 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_parameter_type_mapping/FunctionParameterTypeMappingContextModelBuilder.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_parameter_type_mapping/FunctionParameterTypeMappingContextModelBuilder.cs @@ -48,34 +48,34 @@ partial void Initialize() "varchar"); param.TypeMapping = StringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar", dbType: System.Data.DbType.AnsiString)); getSqlFragmentStatic.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None); @@ -84,7 +84,7 @@ partial void Initialize() AddAnnotation("Relational:DbFunctions", functions); AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); AddAnnotation("Relational:MaxIdentifierLength", 64); - AddRuntimeAnnotation("Relational:RelationalModel", CreateRelationalModel()); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); } private IRelationalModel CreateRelationalModel() diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_type_mapping/FunctionTypeMappingContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_type_mapping/FunctionTypeMappingContextAssemblyAttributes.cs new file mode 100644 index 000000000..7ab16249c --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_type_mapping/FunctionTypeMappingContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Scaffolding; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(CompiledModelRelationalTestBase.FunctionTypeMappingContext), typeof(FunctionTypeMappingContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_type_mapping/FunctionTypeMappingContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_type_mapping/FunctionTypeMappingContextModelBuilder.cs index 43cff4731..ddfc0ef10 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_type_mapping/FunctionTypeMappingContextModelBuilder.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Custom_function_type_mapping/FunctionTypeMappingContextModelBuilder.cs @@ -48,34 +48,34 @@ partial void Initialize() "longtext"); param.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "longtext"), storeTypePostfix: StoreTypePostfix.None); getSqlFragmentStatic.TypeMapping = StringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "varchar", dbType: System.Data.DbType.AnsiString)); @@ -84,7 +84,7 @@ partial void Initialize() AddAnnotation("Relational:DbFunctions", functions); AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); AddAnnotation("Relational:MaxIdentifierLength", 64); - AddRuntimeAnnotation("Relational:RelationalModel", CreateRelationalModel()); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); } private IRelationalModel CreateRelationalModel() diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DataEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DataEntityType.cs index 37b125561..025ab0c0d 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DataEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DataEntityType.cs @@ -1,11 +1,16 @@ // using System; using System.Collections; +using System.Collections.Generic; using System.Linq; using System.Reflection; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage; using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; #pragma warning disable 219, 612, 618 @@ -13,7 +18,8 @@ namespace TestNamespace { - internal partial class DataEntityType + [EntityFrameworkInternal] + public partial class DataEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -29,19 +35,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.Data).GetProperty("Blob", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.Data).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + blob.SetGetter( + byte[] (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity), + bool (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity) == null, + byte[] (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance), + bool (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance) == null); + blob.SetSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetMaterializationSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetAccessors( + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(blob, 0), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(blob), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + blob.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); blob.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray())); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray())); blob.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); return runtimeEntityType; @@ -49,6 +76,31 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var blob = runtimeEntityType.FindProperty("Blob"); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.Data)(source.Entity)); + return ((ISnapshot)(new Snapshot((source.GetCurrentValue(blob) == null ? null : ((ValueComparer)(((IProperty)blob).GetValueComparer())).Snapshot(source.GetCurrentValue(blob)))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => Snapshot.Empty); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => Snapshot.Empty); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => Snapshot.Empty); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => Snapshot.Empty); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => Snapshot.Empty); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 1, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 1, + shadowCount: 0, + relationshipCount: 0, + storeGeneratedCount: 0); runtimeEntityType.AddAnnotation("Relational:FunctionName", "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelRelationalTestBase+DbFunctionContext.GetData()"); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DataUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DataUnsafeAccessors.cs new file mode 100644 index 000000000..193c89702 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DataUnsafeAccessors.cs @@ -0,0 +1,16 @@ +// +using System; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DataUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[] Blob(CompiledModelTestBase.Data @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DbFunctionContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DbFunctionContextAssemblyAttributes.cs new file mode 100644 index 000000000..a248efefd --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DbFunctionContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Scaffolding; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(CompiledModelRelationalTestBase.DbFunctionContext), typeof(DbFunctionContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DbFunctionContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DbFunctionContextModelBuilder.cs index 1a636e5c3..994a14b1c 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DbFunctionContextModelBuilder.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/DbFunctionContextModelBuilder.cs @@ -68,17 +68,17 @@ partial void Initialize() "char(36)"); id.TypeMapping = MySqlGuidTypeMapping.Default.Clone( comparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), keyComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v), + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v), providerValueComparer: new ValueComparer( - (Guid v1, Guid v2) => v1 == v2, - (Guid v) => v.GetHashCode(), - (Guid v) => v)); + bool (Guid v1, Guid v2) => v1 == v2, + int (Guid v) => ((object)v).GetHashCode(), + Guid (Guid v) => v)); id.AddAnnotation("MyAnnotation", new[] { 1L }); var condition = getCount.AddParameter( @@ -88,17 +88,17 @@ partial void Initialize() "char(256)"); condition.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "char(256)", size: 256, @@ -107,17 +107,17 @@ partial void Initialize() getCount.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); functions["Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelRelationalTestBase+DbFunctionContext.GetCount(System.Guid?,string)"] = getCount; var getData = new RuntimeDbFunction( @@ -153,17 +153,17 @@ partial void Initialize() "int"); id0.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); functions["Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelRelationalTestBase+DbFunctionContext.GetData(int)"] = getData0; @@ -190,17 +190,17 @@ partial void Initialize() "char(256)"); date.TypeMapping = MySqlStringTypeMapping.Default.Clone( comparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), keyComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), providerValueComparer: new ValueComparer( - (string v1, string v2) => v1 == v2, - (string v) => v.GetHashCode(), - (string v) => v), + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), mappingInfo: new RelationalTypeMappingInfo( storeTypeName: "char(256)", size: 256, @@ -209,24 +209,24 @@ partial void Initialize() isDateStatic.TypeMapping = MySqlBoolTypeMapping.Default.Clone( comparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), keyComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v), + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), providerValueComparer: new ValueComparer( - (bool v1, bool v2) => v1 == v2, - (bool v) => v.GetHashCode(), - (bool v) => v)); + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v)); isDateStatic.AddAnnotation("MyGuid", new Guid("00000000-0000-0000-0000-000000000000")); functions["Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelRelationalTestBase+DbFunctionContext.IsDateStatic(string)"] = isDateStatic; AddAnnotation("Relational:DbFunctions", functions); AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); AddAnnotation("Relational:MaxIdentifierLength", 64); - AddRuntimeAnnotation("Relational:RelationalModel", CreateRelationalModel()); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); } private IRelationalModel CreateRelationalModel() diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/ObjectEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/ObjectEntityType.cs index ffdea2f12..a09facf3c 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/ObjectEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/DbFunctions/ObjectEntityType.cs @@ -1,14 +1,19 @@ // using System; +using System.Collections.Generic; using System.Reflection; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; #pragma warning disable 219, 612, 618 #nullable disable namespace TestNamespace { - internal partial class ObjectEntityType + [EntityFrameworkInternal] + public partial class ObjectEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -23,6 +28,26 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => Snapshot.Empty); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => Snapshot.Empty); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => Snapshot.Empty); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => Snapshot.Empty); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => Snapshot.Empty); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => Snapshot.Empty); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 0, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 0, + shadowCount: 0, + relationshipCount: 0, + storeGeneratedCount: 0); runtimeEntityType.AddAnnotation("Relational:FunctionName", "GetBlobs()"); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DataEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DataEntityType.cs index e4ea3b2fa..6771fc2c4 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DataEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DataEntityType.cs @@ -1,11 +1,16 @@ // using System; using System.Collections; +using System.Collections.Generic; using System.Linq; using System.Reflection; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage; using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; #pragma warning disable 219, 612, 618 @@ -13,7 +18,8 @@ namespace TestNamespace { - internal partial class DataEntityType + [EntityFrameworkInternal] + public partial class DataEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -30,19 +36,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueGenerated: ValueGenerated.OnAdd, afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: 0); + id.SetAccessors( + int (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(0) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(0) && entry.ReadShadowValue(0) == 0 ? entry.ReadTemporaryValue(0) : entry.ReadShadowValue(0))), + int (InternalEntityEntry entry) => entry.ReadShadowValue(0), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 0), + int (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + id.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: 0, + relationshipIndex: 0, + storeGenerationIndex: 0); id.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); + id.SetCurrentValueComparer(new EntryCurrentValueComparer(id)); id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); var blob = runtimeEntityType.AddProperty( @@ -51,19 +70,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.Data).GetProperty("Blob", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.Data).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + blob.SetGetter( + byte[] (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity), + bool (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity) == null, + byte[] (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance), + bool (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance) == null); + blob.SetSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetMaterializationSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetAccessors( + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(blob, 1), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(blob), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + blob.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); blob.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray())); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray())); blob.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var key = runtimeEntityType.AddKey( @@ -75,6 +115,39 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var id = runtimeEntityType.FindProperty("Id"); + var blob = runtimeEntityType.FindProperty("Blob"); + var key = runtimeEntityType.FindKey(new[] { id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateSimpleNonNullableFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory(key)); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.Data)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id)), (source.GetCurrentValue(blob) == null ? null : ((ValueComparer)(((IProperty)blob).GetValueComparer())).Snapshot(source.GetCurrentValue(blob)))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(default(int)))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(int))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("Id") ? ((int)(source["Id"])) : 0))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(int))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.Data)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 2, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 2, + shadowCount: 1, + relationshipCount: 1, + storeGeneratedCount: 1); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DataUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DataUnsafeAccessors.cs new file mode 100644 index 000000000..193c89702 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DataUnsafeAccessors.cs @@ -0,0 +1,16 @@ +// +using System; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DataUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[] Blob(CompiledModelTestBase.Data @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DbContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DbContextAssemblyAttributes.cs new file mode 100644 index 000000000..c224873f6 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DbContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(DbContext), typeof(DbContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DbContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DbContextModelBuilder.cs index 8b735b26a..01ee5202f 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DbContextModelBuilder.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Dynamic_schema/DbContextModelBuilder.cs @@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; using Microsoft.EntityFrameworkCore.Metadata.Internal; +using Microsoft.EntityFrameworkCore.Update.Internal; #pragma warning disable 219, 612, 618 #nullable disable @@ -26,7 +27,7 @@ partial void Initialize() AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); AddAnnotation("Relational:MaxIdentifierLength", 64); - AddRuntimeAnnotation("Relational:RelationalModel", CreateRelationalModel()); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); } private IRelationalModel CreateRelationalModel() @@ -57,25 +58,28 @@ private IRelationalModel CreateRelationalModel() var dataTable = new Table("Data", null, relationalModel); var idColumn = new Column("Id", "int", dataTable); dataTable.Columns.Add("Id", idColumn); + idColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn); var blobColumn = new Column("Blob", "longblob", dataTable) { IsNullable = true }; dataTable.Columns.Add("Blob", blobColumn); - var pK_Data = new UniqueConstraint("PK_Data", dataTable, new[] { idColumn }); - dataTable.PrimaryKey = pK_Data; - var pK_DataUc = RelationalModel.GetKey(this, - "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", - new[] { "Id" }); - pK_Data.MappedKeys.Add(pK_DataUc); - RelationalModel.GetOrCreateUniqueConstraints(pK_DataUc).Add(pK_Data); - dataTable.UniqueConstraints.Add("PK_Data", pK_Data); + blobColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(blobColumn); relationalModel.Tables.Add(("Data", null), dataTable); var dataTableMapping = new TableMapping(data, dataTable, null); dataTable.AddTypeMapping(dataTableMapping, false); tableMappings.Add(dataTableMapping); RelationalModel.CreateColumnMapping(idColumn, data.FindProperty("Id")!, dataTableMapping); RelationalModel.CreateColumnMapping(blobColumn, data.FindProperty("Blob")!, dataTableMapping); + var pK_Data = new UniqueConstraint("PK_Data", dataTable, new[] { idColumn }); + dataTable.PrimaryKey = pK_Data; + pK_Data.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(pK_Data)); + var pK_DataKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", + new[] { "Id" }); + pK_Data.MappedKeys.Add(pK_DataKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_DataKey).Add(pK_Data); + dataTable.UniqueConstraints.Add("PK_Data", pK_Data); return relationalModel.MakeReadOnly(); } } diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DataEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DataEntityType.cs new file mode 100644 index 000000000..6648a7599 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DataEntityType.cs @@ -0,0 +1,94 @@ +// +using System; +using System.Reflection; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using NetTopologySuite.Geometries; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class DataEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", + typeof(CompiledModelTestBase.Data), + baseEntityType, + propertyCount: 5, + keyCount: 1); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(int), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: 0); + id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); + + var blob = runtimeEntityType.AddProperty( + "Blob", + typeof(byte[]), + propertyInfo: typeof(CompiledModelTestBase.Data).GetProperty("Blob", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.Data).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + blob.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var point = runtimeEntityType.AddProperty( + "Point", + typeof(Point), + nullable: true); + point.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringWithCharSet = runtimeEntityType.AddProperty( + "StringWithCharSet", + typeof(string), + nullable: true, + valueGenerated: ValueGenerated.OnAdd, + valueConverter: new CastingConverter(), + valueComparer: new CompiledModelTestBase.CustomValueComparer(), + providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + stringWithCharSet.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + stringWithCharSet.AddAnnotation("Relational:ColumnType", "varchar(128)"); + stringWithCharSet.AddAnnotation("Relational:DefaultValue", "String having charset"); + + var stringWithCollation = runtimeEntityType.AddProperty( + "StringWithCollation", + typeof(string), + nullable: true, + valueGenerated: ValueGenerated.OnAdd, + valueConverter: new CastingConverter(), + valueComparer: new CompiledModelTestBase.CustomValueComparer(), + providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + stringWithCollation.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + stringWithCollation.AddAnnotation("Relational:ColumnType", "varchar(128)"); + stringWithCollation.AddAnnotation("Relational:DefaultValue", "String using collation"); + + 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", "Data"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DbContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DbContextAssemblyAttributes.cs new file mode 100644 index 000000000..c224873f6 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DbContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(DbContext), typeof(DbContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DbContextModel.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DbContextModel.cs new file mode 100644 index 000000000..583ee4d90 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DbContextModel.cs @@ -0,0 +1,48 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [DbContext(typeof(DbContext))] + public partial class DbContextModel : RuntimeModel + { + private static readonly bool _useOldBehavior31751 = + System.AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue31751", out var enabled31751) && enabled31751; + + static DbContextModel() + { + var model = new DbContextModel(); + + 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 = (DbContextModel)model.FinalizeModel(); + } + + private static DbContextModel _instance; + public static IModel Instance => _instance; + + partial void Initialize(); + + partial void Customize(); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DbContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DbContextModelBuilder.cs new file mode 100644 index 000000000..079ee82de --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DbContextModelBuilder.cs @@ -0,0 +1,56 @@ +// +using System; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public partial class DbContextModel + { + private DbContextModel() + : base(skipDetectChanges: false, modelId: new Guid("00000000-0000-0000-0000-000000000000"), entityTypeCount: 9) + { + } + + partial void Initialize() + { + var data = DataEntityType.Create(this); + var dependentBase = DependentBaseEntityType.Create(this); + var manyTypes = ManyTypesEntityType.Create(this); + var principalBase = PrincipalBaseEntityType.Create(this); + var ownedType = OwnedTypeEntityType.Create(this); + var ownedType0 = OwnedType0EntityType.Create(this); + var principalBasePrincipalDerivedDependentBasebyte = PrincipalBasePrincipalDerivedDependentBasebyteEntityType.Create(this); + var dependentDerived = DependentDerivedEntityType.Create(this, dependentBase); + var principalDerived = PrincipalDerivedEntityType.Create(this, principalBase); + + DependentBaseEntityType.CreateForeignKey1(dependentBase, principalBase); + DependentBaseEntityType.CreateForeignKey2(dependentBase, principalDerived); + OwnedTypeEntityType.CreateForeignKey1(ownedType, principalBase); + OwnedTypeEntityType.CreateForeignKey2(ownedType, ownedType); + OwnedType0EntityType.CreateForeignKey1(ownedType0, principalDerived); + PrincipalBasePrincipalDerivedDependentBasebyteEntityType.CreateForeignKey1(principalBasePrincipalDerivedDependentBasebyte, principalDerived); + PrincipalBasePrincipalDerivedDependentBasebyteEntityType.CreateForeignKey2(principalBasePrincipalDerivedDependentBasebyte, principalBase); + PrincipalDerivedEntityType.CreateForeignKey1(principalDerived, principalBase); + + PrincipalBaseEntityType.CreateSkipNavigation1(principalBase, principalDerived, principalBasePrincipalDerivedDependentBasebyte); + PrincipalDerivedEntityType.CreateSkipNavigation1(principalDerived, principalBase, principalBasePrincipalDerivedDependentBasebyte); + + DataEntityType.CreateAnnotations(data); + DependentBaseEntityType.CreateAnnotations(dependentBase); + ManyTypesEntityType.CreateAnnotations(manyTypes); + PrincipalBaseEntityType.CreateAnnotations(principalBase); + OwnedTypeEntityType.CreateAnnotations(ownedType); + OwnedType0EntityType.CreateAnnotations(ownedType0); + PrincipalBasePrincipalDerivedDependentBasebyteEntityType.CreateAnnotations(principalBasePrincipalDerivedDependentBasebyte); + DependentDerivedEntityType.CreateAnnotations(dependentDerived); + PrincipalDerivedEntityType.CreateAnnotations(principalDerived); + + AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); + AddAnnotation("Relational:MaxIdentifierLength", 64); + } + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DependentBaseEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DependentBaseEntityType.cs new file mode 100644 index 000000000..7816f05ad --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DependentBaseEntityType.cs @@ -0,0 +1,130 @@ +// +using System; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.ValueGeneration; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class DependentBaseEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", + typeof(CompiledModelTestBase.DependentBase), + baseEntityType, + discriminatorProperty: "EnumDiscriminator", + discriminatorValue: CompiledModelTestBase.Enum1.One, + derivedTypesCount: 1, + propertyCount: 4, + navigationCount: 1, + foreignKeyCount: 2, + unnamedIndexCount: 1, + keyCount: 1); + + var principalId = runtimeEntityType.AddProperty( + "PrincipalId", + typeof(long), + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: 0L); + principalId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var principalAlternateId = runtimeEntityType.AddProperty( + "PrincipalAlternateId", + typeof(Guid), + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + principalAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumDiscriminator = runtimeEntityType.AddProperty( + "EnumDiscriminator", + typeof(CompiledModelTestBase.Enum1), + afterSaveBehavior: PropertySaveBehavior.Throw, + valueGeneratorFactory: new DiscriminatorValueGeneratorFactory().Create); + enumDiscriminator.SetSentinelFromProviderValue(0); + enumDiscriminator.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(byte?), + propertyInfo: typeof(CompiledModelTestBase.DependentBase).GetProperty("Id", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.DependentBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var key = runtimeEntityType.AddKey( + new[] { principalId, principalAlternateId }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { principalId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PrincipalId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + unique: true, + required: true); + + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PrincipalId"), declaringEntityType.FindProperty("PrincipalAlternateId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id"), principalEntityType.FindProperty("AlternateId") }), + principalEntityType, + deleteBehavior: DeleteBehavior.ClientNoAction, + unique: true, + required: true); + + var principal = declaringEntityType.AddNavigation("Principal", + runtimeForeignKey, + onDependent: true, + typeof(CompiledModelTestBase.PrincipalDerived>), + propertyInfo: typeof(CompiledModelTestBase.DependentBase).GetProperty("Principal", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.DependentBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + var dependent = principalEntityType.AddNavigation("Dependent", + runtimeForeignKey, + onDependent: false, + typeof(CompiledModelTestBase.DependentBase), + propertyInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetProperty("Dependent", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + eagerLoaded: true, + lazyLoadingEnabled: false); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("DiscriminatorMappingComplete", false); + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:MappingStrategy", "TPH"); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "DependentBase"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DependentDerivedEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DependentDerivedEntityType.cs new file mode 100644 index 000000000..3755ad99a --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/DependentDerivedEntityType.cs @@ -0,0 +1,62 @@ +// +using System; +using System.Reflection; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class DependentDerivedEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentDerived", + typeof(CompiledModelTestBase.DependentDerived), + baseEntityType, + discriminatorProperty: "EnumDiscriminator", + discriminatorValue: CompiledModelTestBase.Enum1.Two, + propertyCount: 2); + + var data = runtimeEntityType.AddProperty( + "Data", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.DependentDerived).GetProperty("Data", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.DependentDerived).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true, + maxLength: 20, + unicode: false); + data.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + data.AddAnnotation("Relational:IsFixedLength", true); + + var money = runtimeEntityType.AddProperty( + "Money", + typeof(decimal), + precision: 9, + scale: 3, + sentinel: 0m); + money.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + 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", "DependentBase"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/ManyTypesEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/ManyTypesEntityType.cs new file mode 100644 index 000000000..13eb6b92e --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/ManyTypesEntityType.cs @@ -0,0 +1,1893 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.NetworkInformation; +using System.Reflection; +using System.Text; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class ManyTypesEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+ManyTypes", + typeof(CompiledModelTestBase.ManyTypes), + baseEntityType, + propertyCount: 236, + keyCount: 1); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(CompiledModelTestBase.ManyTypesId), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + valueConverter: new CompiledModelTestBase.ManyTypesIdConverter()); + id.SetSentinelFromProviderValue(0); + id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); + + var @bool = runtimeEntityType.AddProperty( + "Bool", + typeof(bool), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Bool", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: false); + @bool.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var boolArray = runtimeEntityType.AddProperty( + "BoolArray", + typeof(bool[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BoolArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + boolArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var boolToStringConverterProperty = runtimeEntityType.AddProperty( + "BoolToStringConverterProperty", + typeof(bool), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BoolToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + boolToStringConverterProperty.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), + keyComparer: new ValueComparer( + bool (bool v1, bool v2) => v1 == v2, + int (bool v) => ((object)v).GetHashCode(), + bool (bool v) => v), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "varchar(1)", + size: 1), + converter: new ValueConverter( + string (bool v) => ((string)((v ? "B" : "A"))), + bool (string v) => !(string.IsNullOrEmpty(v)) && ((int)(v.ToUpperInvariant()[0])) == ((int)("B".ToUpperInvariant()[0]))), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + string (bool v) => ((string)((v ? "B" : "A"))), + bool (string v) => !(string.IsNullOrEmpty(v)) && ((int)(v.ToUpperInvariant()[0])) == ((int)("B".ToUpperInvariant()[0]))))); + boolToStringConverterProperty.SetSentinelFromProviderValue("A"); + boolToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var boolToTwoValuesConverterProperty = runtimeEntityType.AddProperty( + "BoolToTwoValuesConverterProperty", + typeof(bool), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BoolToTwoValuesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + boolToTwoValuesConverterProperty.SetValueConverter(new ValueConverter( + byte (bool v) => ((byte)((v ? 1 : 0))), + bool (byte v) => v == 1)); + boolToTwoValuesConverterProperty.SetSentinelFromProviderValue((byte)0); + boolToTwoValuesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var boolToZeroOneConverterProperty = runtimeEntityType.AddProperty( + "BoolToZeroOneConverterProperty", + typeof(bool), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BoolToZeroOneConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new BoolToZeroOneConverter()); + boolToZeroOneConverterProperty.SetSentinelFromProviderValue((short)0); + boolToZeroOneConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var bytes = runtimeEntityType.AddProperty( + "Bytes", + typeof(byte[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Bytes", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + bytes.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var bytesArray = runtimeEntityType.AddProperty( + "BytesArray", + typeof(byte[][]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BytesArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + bytesArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var bytesToStringConverterProperty = runtimeEntityType.AddProperty( + "BytesToStringConverterProperty", + typeof(byte[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("BytesToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new BytesToStringConverter(), + valueComparer: new ArrayStructuralComparer()); + bytesToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var castingConverterProperty = runtimeEntityType.AddProperty( + "CastingConverterProperty", + typeof(int), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("CastingConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new CastingConverter()); + castingConverterProperty.SetSentinelFromProviderValue(0m); + castingConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var @char = runtimeEntityType.AddProperty( + "Char", + typeof(char), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Char", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + @char.SetSentinelFromProviderValue("\0"); + @char.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var charArray = runtimeEntityType.AddProperty( + "CharArray", + typeof(char[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("CharArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + charArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var charToStringConverterProperty = runtimeEntityType.AddProperty( + "CharToStringConverterProperty", + typeof(char), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("CharToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new CharToStringConverter()); + charToStringConverterProperty.SetSentinelFromProviderValue("\0"); + charToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateOnly = runtimeEntityType.AddProperty( + "DateOnly", + typeof(DateOnly), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateOnly", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new DateOnly(1, 1, 1)); + dateOnly.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateOnlyArray = runtimeEntityType.AddProperty( + "DateOnlyArray", + typeof(DateOnly[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateOnlyArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + dateOnlyArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateOnlyToStringConverterProperty = runtimeEntityType.AddProperty( + "DateOnlyToStringConverterProperty", + typeof(DateOnly), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateOnlyToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new DateOnlyToStringConverter()); + dateOnlyToStringConverterProperty.SetSentinelFromProviderValue("0001-01-01"); + dateOnlyToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateTime = runtimeEntityType.AddProperty( + "DateTime", + typeof(DateTime), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTime", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified)); + dateTime.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateTimeArray = runtimeEntityType.AddProperty( + "DateTimeArray", + typeof(DateTime[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + dateTimeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateTimeOffsetToBinaryConverterProperty = runtimeEntityType.AddProperty( + "DateTimeOffsetToBinaryConverterProperty", + typeof(DateTimeOffset), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeOffsetToBinaryConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new DateTimeOffsetToBinaryConverter()); + dateTimeOffsetToBinaryConverterProperty.SetSentinelFromProviderValue(0L); + dateTimeOffsetToBinaryConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateTimeOffsetToBytesConverterProperty = runtimeEntityType.AddProperty( + "DateTimeOffsetToBytesConverterProperty", + typeof(DateTimeOffset), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeOffsetToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new DateTimeOffsetToBytesConverter()); + dateTimeOffsetToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); + dateTimeOffsetToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateTimeOffsetToStringConverterProperty = runtimeEntityType.AddProperty( + "DateTimeOffsetToStringConverterProperty", + typeof(DateTimeOffset), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeOffsetToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new DateTimeOffsetToStringConverter()); + dateTimeOffsetToStringConverterProperty.SetSentinelFromProviderValue("0001-01-01 00:00:00+00:00"); + dateTimeOffsetToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateTimeToBinaryConverterProperty = runtimeEntityType.AddProperty( + "DateTimeToBinaryConverterProperty", + typeof(DateTime), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeToBinaryConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new DateTimeToBinaryConverter()); + dateTimeToBinaryConverterProperty.SetSentinelFromProviderValue(0L); + dateTimeToBinaryConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateTimeToStringConverterProperty = runtimeEntityType.AddProperty( + "DateTimeToStringConverterProperty", + typeof(DateTime), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new DateTimeToStringConverter()); + dateTimeToStringConverterProperty.SetSentinelFromProviderValue("0001-01-01 00:00:00"); + dateTimeToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var dateTimeToTicksConverterProperty = runtimeEntityType.AddProperty( + "DateTimeToTicksConverterProperty", + typeof(DateTime), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DateTimeToTicksConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified)); + dateTimeToTicksConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var @decimal = runtimeEntityType.AddProperty( + "Decimal", + typeof(decimal), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Decimal", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0m); + @decimal.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var decimalArray = runtimeEntityType.AddProperty( + "DecimalArray", + typeof(decimal[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DecimalArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + decimalArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var decimalNumberToBytesConverterProperty = runtimeEntityType.AddProperty( + "DecimalNumberToBytesConverterProperty", + typeof(decimal), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DecimalNumberToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new NumberToBytesConverter()); + decimalNumberToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); + decimalNumberToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var decimalNumberToStringConverterProperty = runtimeEntityType.AddProperty( + "DecimalNumberToStringConverterProperty", + typeof(decimal), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DecimalNumberToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new NumberToStringConverter()); + decimalNumberToStringConverterProperty.SetSentinelFromProviderValue("0"); + decimalNumberToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var @double = runtimeEntityType.AddProperty( + "Double", + typeof(double), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Double", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0.0); + @double.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var doubleArray = runtimeEntityType.AddProperty( + "DoubleArray", + typeof(double[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DoubleArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + doubleArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var doubleNumberToBytesConverterProperty = runtimeEntityType.AddProperty( + "DoubleNumberToBytesConverterProperty", + typeof(double), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DoubleNumberToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new NumberToBytesConverter()); + doubleNumberToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }); + doubleNumberToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var doubleNumberToStringConverterProperty = runtimeEntityType.AddProperty( + "DoubleNumberToStringConverterProperty", + typeof(double), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("DoubleNumberToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new NumberToStringConverter()); + doubleNumberToStringConverterProperty.SetSentinelFromProviderValue("0"); + doubleNumberToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum16 = runtimeEntityType.AddProperty( + "Enum16", + typeof(CompiledModelTestBase.Enum16), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16.SetSentinelFromProviderValue((short)0); + enum16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum16Array = runtimeEntityType.AddProperty( + "Enum16Array", + typeof(CompiledModelTestBase.Enum16[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum16AsString = runtimeEntityType.AddProperty( + "Enum16AsString", + typeof(CompiledModelTestBase.Enum16), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + providerPropertyType: typeof(string)); + enum16AsString.SetSentinelFromProviderValue("Default"); + enum16AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum16AsStringArray = runtimeEntityType.AddProperty( + "Enum16AsStringArray", + typeof(CompiledModelTestBase.Enum16[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum16AsStringCollection = runtimeEntityType.AddProperty( + "Enum16AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum16Collection = runtimeEntityType.AddProperty( + "Enum16Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum16Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum16Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum32 = runtimeEntityType.AddProperty( + "Enum32", + typeof(CompiledModelTestBase.Enum32), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32.SetSentinelFromProviderValue(0); + enum32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum32Array = runtimeEntityType.AddProperty( + "Enum32Array", + typeof(CompiledModelTestBase.Enum32[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum32AsString = runtimeEntityType.AddProperty( + "Enum32AsString", + typeof(CompiledModelTestBase.Enum32), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + providerPropertyType: typeof(string)); + enum32AsString.SetSentinelFromProviderValue("Default"); + enum32AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum32AsStringArray = runtimeEntityType.AddProperty( + "Enum32AsStringArray", + typeof(CompiledModelTestBase.Enum32[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum32AsStringCollection = runtimeEntityType.AddProperty( + "Enum32AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum32Collection = runtimeEntityType.AddProperty( + "Enum32Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum32Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum32Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum64 = runtimeEntityType.AddProperty( + "Enum64", + typeof(CompiledModelTestBase.Enum64), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64.SetSentinelFromProviderValue(0L); + enum64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum64Array = runtimeEntityType.AddProperty( + "Enum64Array", + typeof(CompiledModelTestBase.Enum64[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum64AsString = runtimeEntityType.AddProperty( + "Enum64AsString", + typeof(CompiledModelTestBase.Enum64), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + providerPropertyType: typeof(string)); + enum64AsString.SetSentinelFromProviderValue("Default"); + enum64AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum64AsStringArray = runtimeEntityType.AddProperty( + "Enum64AsStringArray", + typeof(CompiledModelTestBase.Enum64[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum64AsStringCollection = runtimeEntityType.AddProperty( + "Enum64AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum64Collection = runtimeEntityType.AddProperty( + "Enum64Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum64Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum64Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum8 = runtimeEntityType.AddProperty( + "Enum8", + typeof(CompiledModelTestBase.Enum8), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8.SetSentinelFromProviderValue((sbyte)0); + enum8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum8Array = runtimeEntityType.AddProperty( + "Enum8Array", + typeof(CompiledModelTestBase.Enum8[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum8AsString = runtimeEntityType.AddProperty( + "Enum8AsString", + typeof(CompiledModelTestBase.Enum8), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + providerPropertyType: typeof(string)); + enum8AsString.SetSentinelFromProviderValue("Default"); + enum8AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum8AsStringArray = runtimeEntityType.AddProperty( + "Enum8AsStringArray", + typeof(CompiledModelTestBase.Enum8[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum8AsStringCollection = runtimeEntityType.AddProperty( + "Enum8AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum8Collection = runtimeEntityType.AddProperty( + "Enum8Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Enum8Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum8Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumToNumberConverterProperty = runtimeEntityType.AddProperty( + "EnumToNumberConverterProperty", + typeof(CompiledModelTestBase.Enum32), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumToNumberConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new EnumToNumberConverter()); + enumToNumberConverterProperty.SetSentinelFromProviderValue(0); + enumToNumberConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumToStringConverterProperty = runtimeEntityType.AddProperty( + "EnumToStringConverterProperty", + typeof(CompiledModelTestBase.Enum32), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new EnumToStringConverter()); + enumToStringConverterProperty.SetSentinelFromProviderValue("Default"); + enumToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU16 = runtimeEntityType.AddProperty( + "EnumU16", + typeof(CompiledModelTestBase.EnumU16), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16.SetSentinelFromProviderValue((ushort)0); + enumU16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU16Array = runtimeEntityType.AddProperty( + "EnumU16Array", + typeof(CompiledModelTestBase.EnumU16[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU16AsString = runtimeEntityType.AddProperty( + "EnumU16AsString", + typeof(CompiledModelTestBase.EnumU16), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + providerPropertyType: typeof(string)); + enumU16AsString.SetSentinelFromProviderValue("Min"); + enumU16AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU16AsStringArray = runtimeEntityType.AddProperty( + "EnumU16AsStringArray", + typeof(CompiledModelTestBase.EnumU16[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU16AsStringCollection = runtimeEntityType.AddProperty( + "EnumU16AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU16Collection = runtimeEntityType.AddProperty( + "EnumU16Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU16Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU16Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU32 = runtimeEntityType.AddProperty( + "EnumU32", + typeof(CompiledModelTestBase.EnumU32), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32.SetSentinelFromProviderValue(0u); + enumU32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU32Array = runtimeEntityType.AddProperty( + "EnumU32Array", + typeof(CompiledModelTestBase.EnumU32[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU32AsString = runtimeEntityType.AddProperty( + "EnumU32AsString", + typeof(CompiledModelTestBase.EnumU32), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + providerPropertyType: typeof(string)); + enumU32AsString.SetSentinelFromProviderValue("Min"); + enumU32AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU32AsStringArray = runtimeEntityType.AddProperty( + "EnumU32AsStringArray", + typeof(CompiledModelTestBase.EnumU32[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU32AsStringCollection = runtimeEntityType.AddProperty( + "EnumU32AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU32Collection = runtimeEntityType.AddProperty( + "EnumU32Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU32Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU32Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU64 = runtimeEntityType.AddProperty( + "EnumU64", + typeof(CompiledModelTestBase.EnumU64), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64.SetSentinelFromProviderValue(0ul); + enumU64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU64Array = runtimeEntityType.AddProperty( + "EnumU64Array", + typeof(CompiledModelTestBase.EnumU64[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU64AsString = runtimeEntityType.AddProperty( + "EnumU64AsString", + typeof(CompiledModelTestBase.EnumU64), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + providerPropertyType: typeof(string)); + enumU64AsString.SetSentinelFromProviderValue("Min"); + enumU64AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU64AsStringArray = runtimeEntityType.AddProperty( + "EnumU64AsStringArray", + typeof(CompiledModelTestBase.EnumU64[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU64AsStringCollection = runtimeEntityType.AddProperty( + "EnumU64AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU64Collection = runtimeEntityType.AddProperty( + "EnumU64Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU64Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU64Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU8 = runtimeEntityType.AddProperty( + "EnumU8", + typeof(CompiledModelTestBase.EnumU8), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8.SetSentinelFromProviderValue((byte)0); + enumU8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU8Array = runtimeEntityType.AddProperty( + "EnumU8Array", + typeof(CompiledModelTestBase.EnumU8[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU8AsString = runtimeEntityType.AddProperty( + "EnumU8AsString", + typeof(CompiledModelTestBase.EnumU8), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + providerPropertyType: typeof(string)); + enumU8AsString.SetSentinelFromProviderValue("Min"); + enumU8AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU8AsStringArray = runtimeEntityType.AddProperty( + "EnumU8AsStringArray", + typeof(CompiledModelTestBase.EnumU8[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU8AsStringCollection = runtimeEntityType.AddProperty( + "EnumU8AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enumU8Collection = runtimeEntityType.AddProperty( + "EnumU8Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("EnumU8Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enumU8Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var @float = runtimeEntityType.AddProperty( + "Float", + typeof(float), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Float", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0f); + @float.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var floatArray = runtimeEntityType.AddProperty( + "FloatArray", + typeof(float[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("FloatArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + floatArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var guid = runtimeEntityType.AddProperty( + "Guid", + typeof(Guid), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Guid", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + guid.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var guidArray = runtimeEntityType.AddProperty( + "GuidArray", + typeof(Guid[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("GuidArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + guidArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var guidToBytesConverterProperty = runtimeEntityType.AddProperty( + "GuidToBytesConverterProperty", + typeof(Guid), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("GuidToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new GuidToBytesConverter()); + guidToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }); + guidToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var guidToStringConverterProperty = runtimeEntityType.AddProperty( + "GuidToStringConverterProperty", + typeof(Guid), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("GuidToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new GuidToStringConverter()); + guidToStringConverterProperty.SetSentinelFromProviderValue("00000000-0000-0000-0000-000000000000"); + guidToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var iPAddress = runtimeEntityType.AddProperty( + "IPAddress", + typeof(IPAddress), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IPAddress", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + iPAddress.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var iPAddressArray = runtimeEntityType.AddProperty( + "IPAddressArray", + typeof(IPAddress[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IPAddressArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + iPAddressArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var iPAddressToBytesConverterProperty = runtimeEntityType.AddProperty( + "IPAddressToBytesConverterProperty", + typeof(IPAddress), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IPAddressToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new IPAddressToBytesConverter()); + iPAddressToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var iPAddressToStringConverterProperty = runtimeEntityType.AddProperty( + "IPAddressToStringConverterProperty", + typeof(IPAddress), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IPAddressToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new IPAddressToStringConverter()); + iPAddressToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var int16 = runtimeEntityType.AddProperty( + "Int16", + typeof(short), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: (short)0); + int16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var int16Array = runtimeEntityType.AddProperty( + "Int16Array", + typeof(short[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + int16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var int32 = runtimeEntityType.AddProperty( + "Int32", + typeof(int), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0); + int32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var int32Array = runtimeEntityType.AddProperty( + "Int32Array", + typeof(int[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + int32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var int64 = runtimeEntityType.AddProperty( + "Int64", + typeof(long), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0L); + int64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var int64Array = runtimeEntityType.AddProperty( + "Int64Array", + typeof(long[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + int64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var int8 = runtimeEntityType.AddProperty( + "Int8", + typeof(sbyte), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: (sbyte)0); + int8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var int8Array = runtimeEntityType.AddProperty( + "Int8Array", + typeof(sbyte[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Int8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + int8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var intNumberToBytesConverterProperty = runtimeEntityType.AddProperty( + "IntNumberToBytesConverterProperty", + typeof(int), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IntNumberToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new NumberToBytesConverter()); + intNumberToBytesConverterProperty.SetSentinelFromProviderValue(new byte[] { 0, 0, 0, 0 }); + intNumberToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var intNumberToStringConverterProperty = runtimeEntityType.AddProperty( + "IntNumberToStringConverterProperty", + typeof(int), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("IntNumberToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new NumberToStringConverter()); + intNumberToStringConverterProperty.SetSentinelFromProviderValue("0"); + intNumberToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullIntToNullStringConverterProperty = runtimeEntityType.AddProperty( + "NullIntToNullStringConverterProperty", + typeof(int?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullIntToNullStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true, + valueConverter: new CompiledModelTestBase.NullIntToNullStringConverter()); + nullIntToNullStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableBool = runtimeEntityType.AddProperty( + "NullableBool", + typeof(bool?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableBool", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableBool.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableBoolArray = runtimeEntityType.AddProperty( + "NullableBoolArray", + typeof(bool?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableBoolArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableBoolArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableBytes = runtimeEntityType.AddProperty( + "NullableBytes", + typeof(byte[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableBytes", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableBytes.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableBytesArray = runtimeEntityType.AddProperty( + "NullableBytesArray", + typeof(byte[][]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableBytesArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableBytesArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableChar = runtimeEntityType.AddProperty( + "NullableChar", + typeof(char?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableChar", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableChar.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableCharArray = runtimeEntityType.AddProperty( + "NullableCharArray", + typeof(char?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableCharArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableCharArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableDateOnly = runtimeEntityType.AddProperty( + "NullableDateOnly", + typeof(DateOnly?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDateOnly", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableDateOnly.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableDateOnlyArray = runtimeEntityType.AddProperty( + "NullableDateOnlyArray", + typeof(DateOnly?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDateOnlyArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableDateOnlyArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableDateTime = runtimeEntityType.AddProperty( + "NullableDateTime", + typeof(DateTime?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDateTime", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableDateTime.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableDateTimeArray = runtimeEntityType.AddProperty( + "NullableDateTimeArray", + typeof(DateTime?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDateTimeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableDateTimeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableDecimal = runtimeEntityType.AddProperty( + "NullableDecimal", + typeof(decimal?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDecimal", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableDecimal.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableDecimalArray = runtimeEntityType.AddProperty( + "NullableDecimalArray", + typeof(decimal?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDecimalArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableDecimalArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableDouble = runtimeEntityType.AddProperty( + "NullableDouble", + typeof(double?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDouble", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableDouble.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableDoubleArray = runtimeEntityType.AddProperty( + "NullableDoubleArray", + typeof(double?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableDoubleArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableDoubleArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum16 = runtimeEntityType.AddProperty( + "NullableEnum16", + typeof(CompiledModelTestBase.Enum16?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnum16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum16Array = runtimeEntityType.AddProperty( + "NullableEnum16Array", + typeof(CompiledModelTestBase.Enum16?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum16AsString = runtimeEntityType.AddProperty( + "NullableEnum16AsString", + typeof(CompiledModelTestBase.Enum16?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnum16AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum16AsStringArray = runtimeEntityType.AddProperty( + "NullableEnum16AsStringArray", + typeof(CompiledModelTestBase.Enum16?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum16AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum16AsStringCollection = runtimeEntityType.AddProperty( + "NullableEnum16AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum16AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum16Collection = runtimeEntityType.AddProperty( + "NullableEnum16Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum16Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum16Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum32 = runtimeEntityType.AddProperty( + "NullableEnum32", + typeof(CompiledModelTestBase.Enum32?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnum32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum32Array = runtimeEntityType.AddProperty( + "NullableEnum32Array", + typeof(CompiledModelTestBase.Enum32?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum32AsString = runtimeEntityType.AddProperty( + "NullableEnum32AsString", + typeof(CompiledModelTestBase.Enum32?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnum32AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum32AsStringArray = runtimeEntityType.AddProperty( + "NullableEnum32AsStringArray", + typeof(CompiledModelTestBase.Enum32?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum32AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum32AsStringCollection = runtimeEntityType.AddProperty( + "NullableEnum32AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum32AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum32Collection = runtimeEntityType.AddProperty( + "NullableEnum32Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum32Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum32Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum64 = runtimeEntityType.AddProperty( + "NullableEnum64", + typeof(CompiledModelTestBase.Enum64?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnum64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum64Array = runtimeEntityType.AddProperty( + "NullableEnum64Array", + typeof(CompiledModelTestBase.Enum64?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum64AsString = runtimeEntityType.AddProperty( + "NullableEnum64AsString", + typeof(CompiledModelTestBase.Enum64?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnum64AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum64AsStringArray = runtimeEntityType.AddProperty( + "NullableEnum64AsStringArray", + typeof(CompiledModelTestBase.Enum64?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum64AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum64AsStringCollection = runtimeEntityType.AddProperty( + "NullableEnum64AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum64AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum64Collection = runtimeEntityType.AddProperty( + "NullableEnum64Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum64Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum64Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum8 = runtimeEntityType.AddProperty( + "NullableEnum8", + typeof(CompiledModelTestBase.Enum8?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnum8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum8Array = runtimeEntityType.AddProperty( + "NullableEnum8Array", + typeof(CompiledModelTestBase.Enum8?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum8AsString = runtimeEntityType.AddProperty( + "NullableEnum8AsString", + typeof(CompiledModelTestBase.Enum8?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnum8AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum8AsStringArray = runtimeEntityType.AddProperty( + "NullableEnum8AsStringArray", + typeof(CompiledModelTestBase.Enum8?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum8AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum8AsStringCollection = runtimeEntityType.AddProperty( + "NullableEnum8AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum8AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnum8Collection = runtimeEntityType.AddProperty( + "NullableEnum8Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnum8Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnum8Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU16 = runtimeEntityType.AddProperty( + "NullableEnumU16", + typeof(CompiledModelTestBase.EnumU16?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnumU16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU16Array = runtimeEntityType.AddProperty( + "NullableEnumU16Array", + typeof(CompiledModelTestBase.EnumU16?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU16AsString = runtimeEntityType.AddProperty( + "NullableEnumU16AsString", + typeof(CompiledModelTestBase.EnumU16?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnumU16AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU16AsStringArray = runtimeEntityType.AddProperty( + "NullableEnumU16AsStringArray", + typeof(CompiledModelTestBase.EnumU16?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU16AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU16AsStringCollection = runtimeEntityType.AddProperty( + "NullableEnumU16AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU16AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU16Collection = runtimeEntityType.AddProperty( + "NullableEnumU16Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU16Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU16Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU32 = runtimeEntityType.AddProperty( + "NullableEnumU32", + typeof(CompiledModelTestBase.EnumU32?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnumU32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU32Array = runtimeEntityType.AddProperty( + "NullableEnumU32Array", + typeof(CompiledModelTestBase.EnumU32?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU32AsString = runtimeEntityType.AddProperty( + "NullableEnumU32AsString", + typeof(CompiledModelTestBase.EnumU32?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnumU32AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU32AsStringArray = runtimeEntityType.AddProperty( + "NullableEnumU32AsStringArray", + typeof(CompiledModelTestBase.EnumU32?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU32AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU32AsStringCollection = runtimeEntityType.AddProperty( + "NullableEnumU32AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU32AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU32Collection = runtimeEntityType.AddProperty( + "NullableEnumU32Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU32Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU32Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU64 = runtimeEntityType.AddProperty( + "NullableEnumU64", + typeof(CompiledModelTestBase.EnumU64?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnumU64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU64Array = runtimeEntityType.AddProperty( + "NullableEnumU64Array", + typeof(CompiledModelTestBase.EnumU64?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU64AsString = runtimeEntityType.AddProperty( + "NullableEnumU64AsString", + typeof(CompiledModelTestBase.EnumU64?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnumU64AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU64AsStringArray = runtimeEntityType.AddProperty( + "NullableEnumU64AsStringArray", + typeof(CompiledModelTestBase.EnumU64?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU64AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU64AsStringCollection = runtimeEntityType.AddProperty( + "NullableEnumU64AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU64AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU64Collection = runtimeEntityType.AddProperty( + "NullableEnumU64Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU64Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU64Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU8 = runtimeEntityType.AddProperty( + "NullableEnumU8", + typeof(CompiledModelTestBase.EnumU8?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnumU8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU8Array = runtimeEntityType.AddProperty( + "NullableEnumU8Array", + typeof(CompiledModelTestBase.EnumU8?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU8AsString = runtimeEntityType.AddProperty( + "NullableEnumU8AsString", + typeof(CompiledModelTestBase.EnumU8?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8AsString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableEnumU8AsString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU8AsStringArray = runtimeEntityType.AddProperty( + "NullableEnumU8AsStringArray", + typeof(CompiledModelTestBase.EnumU8?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8AsStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU8AsStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU8AsStringCollection = runtimeEntityType.AddProperty( + "NullableEnumU8AsStringCollection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8AsStringCollection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU8AsStringCollection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableEnumU8Collection = runtimeEntityType.AddProperty( + "NullableEnumU8Collection", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableEnumU8Collection", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableEnumU8Collection.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableFloat = runtimeEntityType.AddProperty( + "NullableFloat", + typeof(float?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableFloat", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableFloat.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableFloatArray = runtimeEntityType.AddProperty( + "NullableFloatArray", + typeof(float?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableFloatArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableFloatArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableGuid = runtimeEntityType.AddProperty( + "NullableGuid", + typeof(Guid?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableGuid", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableGuid.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableGuidArray = runtimeEntityType.AddProperty( + "NullableGuidArray", + typeof(Guid?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableGuidArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableGuidArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableIPAddress = runtimeEntityType.AddProperty( + "NullableIPAddress", + typeof(IPAddress), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableIPAddress", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableIPAddress.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableIPAddressArray = runtimeEntityType.AddProperty( + "NullableIPAddressArray", + typeof(IPAddress[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableIPAddressArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableIPAddressArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableInt16 = runtimeEntityType.AddProperty( + "NullableInt16", + typeof(short?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableInt16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableInt16Array = runtimeEntityType.AddProperty( + "NullableInt16Array", + typeof(short?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableInt16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableInt32 = runtimeEntityType.AddProperty( + "NullableInt32", + typeof(int?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableInt32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableInt32Array = runtimeEntityType.AddProperty( + "NullableInt32Array", + typeof(int?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableInt32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableInt64 = runtimeEntityType.AddProperty( + "NullableInt64", + typeof(long?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableInt64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableInt64Array = runtimeEntityType.AddProperty( + "NullableInt64Array", + typeof(long?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableInt64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableInt8 = runtimeEntityType.AddProperty( + "NullableInt8", + typeof(sbyte?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableInt8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableInt8Array = runtimeEntityType.AddProperty( + "NullableInt8Array", + typeof(sbyte?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableInt8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableInt8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullablePhysicalAddress = runtimeEntityType.AddProperty( + "NullablePhysicalAddress", + typeof(PhysicalAddress), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullablePhysicalAddress", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullablePhysicalAddress.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullablePhysicalAddressArray = runtimeEntityType.AddProperty( + "NullablePhysicalAddressArray", + typeof(PhysicalAddress[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullablePhysicalAddressArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullablePhysicalAddressArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableString = runtimeEntityType.AddProperty( + "NullableString", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableString", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableString.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableStringArray = runtimeEntityType.AddProperty( + "NullableStringArray", + typeof(string[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableStringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableStringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableTimeOnly = runtimeEntityType.AddProperty( + "NullableTimeOnly", + typeof(TimeOnly?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableTimeOnly", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableTimeOnly.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableTimeOnlyArray = runtimeEntityType.AddProperty( + "NullableTimeOnlyArray", + typeof(TimeOnly?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableTimeOnlyArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableTimeOnlyArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableTimeSpan = runtimeEntityType.AddProperty( + "NullableTimeSpan", + typeof(TimeSpan?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableTimeSpan", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableTimeSpan.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableTimeSpanArray = runtimeEntityType.AddProperty( + "NullableTimeSpanArray", + typeof(TimeSpan?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableTimeSpanArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableTimeSpanArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUInt16 = runtimeEntityType.AddProperty( + "NullableUInt16", + typeof(ushort?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableUInt16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUInt16Array = runtimeEntityType.AddProperty( + "NullableUInt16Array", + typeof(ushort?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUInt16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUInt32 = runtimeEntityType.AddProperty( + "NullableUInt32", + typeof(uint?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableUInt32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUInt32Array = runtimeEntityType.AddProperty( + "NullableUInt32Array", + typeof(uint?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUInt32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUInt64 = runtimeEntityType.AddProperty( + "NullableUInt64", + typeof(ulong?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableUInt64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUInt64Array = runtimeEntityType.AddProperty( + "NullableUInt64Array", + typeof(ulong?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUInt64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUInt8 = runtimeEntityType.AddProperty( + "NullableUInt8", + typeof(byte?), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableUInt8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUInt8Array = runtimeEntityType.AddProperty( + "NullableUInt8Array", + typeof(byte?[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUInt8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUInt8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUri = runtimeEntityType.AddProperty( + "NullableUri", + typeof(Uri), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUri", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + nullableUri.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var nullableUriArray = runtimeEntityType.AddProperty( + "NullableUriArray", + typeof(Uri[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("NullableUriArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + nullableUriArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var physicalAddress = runtimeEntityType.AddProperty( + "PhysicalAddress", + typeof(PhysicalAddress), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("PhysicalAddress", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + physicalAddress.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var physicalAddressArray = runtimeEntityType.AddProperty( + "PhysicalAddressArray", + typeof(PhysicalAddress[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("PhysicalAddressArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + physicalAddressArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var physicalAddressToBytesConverterProperty = runtimeEntityType.AddProperty( + "PhysicalAddressToBytesConverterProperty", + typeof(PhysicalAddress), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("PhysicalAddressToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new PhysicalAddressToBytesConverter()); + physicalAddressToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var physicalAddressToStringConverterProperty = runtimeEntityType.AddProperty( + "PhysicalAddressToStringConverterProperty", + typeof(PhysicalAddress), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("PhysicalAddressToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new PhysicalAddressToStringConverter()); + physicalAddressToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var @string = runtimeEntityType.AddProperty( + "String", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("String", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + @string.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringArray = runtimeEntityType.AddProperty( + "StringArray", + typeof(string[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + stringArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToBoolConverterProperty = runtimeEntityType.AddProperty( + "StringToBoolConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToBoolConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToBoolConverter()); + stringToBoolConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToBytesConverterProperty = runtimeEntityType.AddProperty( + "StringToBytesConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToBytesConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + stringToBytesConverterProperty.SetValueConverter(new ValueConverter( + byte[] (string v) => Encoding.GetEncoding(12000).GetBytes(v), + string (byte[] v) => Encoding.GetEncoding(12000).GetString(v))); + stringToBytesConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToCharConverterProperty = runtimeEntityType.AddProperty( + "StringToCharConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToCharConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToCharConverter()); + stringToCharConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToDateOnlyConverterProperty = runtimeEntityType.AddProperty( + "StringToDateOnlyConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDateOnlyConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToDateOnlyConverter()); + stringToDateOnlyConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToDateTimeConverterProperty = runtimeEntityType.AddProperty( + "StringToDateTimeConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDateTimeConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToDateTimeConverter()); + stringToDateTimeConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToDateTimeOffsetConverterProperty = runtimeEntityType.AddProperty( + "StringToDateTimeOffsetConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDateTimeOffsetConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToDateTimeOffsetConverter()); + stringToDateTimeOffsetConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToDecimalNumberConverterProperty = runtimeEntityType.AddProperty( + "StringToDecimalNumberConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDecimalNumberConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToNumberConverter()); + stringToDecimalNumberConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToDoubleNumberConverterProperty = runtimeEntityType.AddProperty( + "StringToDoubleNumberConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToDoubleNumberConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToNumberConverter()); + stringToDoubleNumberConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToEnumConverterProperty = runtimeEntityType.AddProperty( + "StringToEnumConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToEnumConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToEnumConverter()); + stringToEnumConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToGuidConverterProperty = runtimeEntityType.AddProperty( + "StringToGuidConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToGuidConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + stringToGuidConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToIntNumberConverterProperty = runtimeEntityType.AddProperty( + "StringToIntNumberConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToIntNumberConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToNumberConverter()); + stringToIntNumberConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToTimeOnlyConverterProperty = runtimeEntityType.AddProperty( + "StringToTimeOnlyConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToTimeOnlyConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToTimeOnlyConverter()); + stringToTimeOnlyConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToTimeSpanConverterProperty = runtimeEntityType.AddProperty( + "StringToTimeSpanConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToTimeSpanConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToTimeSpanConverter()); + stringToTimeSpanConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringToUriConverterProperty = runtimeEntityType.AddProperty( + "StringToUriConverterProperty", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("StringToUriConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new StringToUriConverter()); + stringToUriConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var timeOnly = runtimeEntityType.AddProperty( + "TimeOnly", + typeof(TimeOnly), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeOnly", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new TimeOnly(0, 0, 0)); + timeOnly.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var timeOnlyArray = runtimeEntityType.AddProperty( + "TimeOnlyArray", + typeof(TimeOnly[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeOnlyArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + timeOnlyArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var timeOnlyToStringConverterProperty = runtimeEntityType.AddProperty( + "TimeOnlyToStringConverterProperty", + typeof(TimeOnly), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeOnlyToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new TimeOnlyToStringConverter()); + timeOnlyToStringConverterProperty.SetSentinelFromProviderValue("00:00:00"); + timeOnlyToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var timeOnlyToTicksConverterProperty = runtimeEntityType.AddProperty( + "TimeOnlyToTicksConverterProperty", + typeof(TimeOnly), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeOnlyToTicksConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new TimeOnlyToTicksConverter()); + timeOnlyToTicksConverterProperty.SetSentinelFromProviderValue(0L); + timeOnlyToTicksConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var timeSpan = runtimeEntityType.AddProperty( + "TimeSpan", + typeof(TimeSpan), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeSpan", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: new TimeSpan(0, 0, 0, 0, 0)); + timeSpan.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var timeSpanArray = runtimeEntityType.AddProperty( + "TimeSpanArray", + typeof(TimeSpan[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeSpanArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + timeSpanArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var timeSpanToStringConverterProperty = runtimeEntityType.AddProperty( + "TimeSpanToStringConverterProperty", + typeof(TimeSpan), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeSpanToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new TimeSpanToStringConverter()); + timeSpanToStringConverterProperty.SetSentinelFromProviderValue("00:00:00"); + timeSpanToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var timeSpanToTicksConverterProperty = runtimeEntityType.AddProperty( + "TimeSpanToTicksConverterProperty", + typeof(TimeSpan), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("TimeSpanToTicksConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new TimeSpanToTicksConverter()); + timeSpanToTicksConverterProperty.SetSentinelFromProviderValue(0L); + timeSpanToTicksConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uInt16 = runtimeEntityType.AddProperty( + "UInt16", + typeof(ushort), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt16", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: (ushort)0); + uInt16.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uInt16Array = runtimeEntityType.AddProperty( + "UInt16Array", + typeof(ushort[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt16Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uInt16Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uInt32 = runtimeEntityType.AddProperty( + "UInt32", + typeof(uint), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt32", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0u); + uInt32.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uInt32Array = runtimeEntityType.AddProperty( + "UInt32Array", + typeof(uint[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt32Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uInt32Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uInt64 = runtimeEntityType.AddProperty( + "UInt64", + typeof(ulong), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt64", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0ul); + uInt64.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uInt64Array = runtimeEntityType.AddProperty( + "UInt64Array", + typeof(ulong[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt64Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uInt64Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uInt8 = runtimeEntityType.AddProperty( + "UInt8", + typeof(byte), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt8", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: (byte)0); + uInt8.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uInt8Array = runtimeEntityType.AddProperty( + "UInt8Array", + typeof(byte[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UInt8Array", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uInt8Array.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uri = runtimeEntityType.AddProperty( + "Uri", + typeof(Uri), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("Uri", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uri.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uriArray = runtimeEntityType.AddProperty( + "UriArray", + typeof(Uri[]), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UriArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + uriArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var uriToStringConverterProperty = runtimeEntityType.AddProperty( + "UriToStringConverterProperty", + typeof(Uri), + propertyInfo: typeof(CompiledModelTestBase.ManyTypes).GetProperty("UriToStringConverterProperty", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.ManyTypes).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueConverter: new UriToStringConverter()); + uriToStringConverterProperty.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + 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", "ManyTypes"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/OwnedType0EntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/OwnedType0EntityType.cs new file mode 100644 index 000000000..3608190b5 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/OwnedType0EntityType.cs @@ -0,0 +1,178 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class OwnedType0EntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>.ManyOwned#OwnedType", + typeof(CompiledModelTestBase.OwnedType), + baseEntityType, + sharedClrType: true, + propertyCount: 13, + servicePropertyCount: 1, + foreignKeyCount: 1, + keyCount: 1); + + var principalDerivedId = runtimeEntityType.AddProperty( + "PrincipalDerivedId", + typeof(long), + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: 0L); + principalDerivedId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var principalDerivedAlternateId = runtimeEntityType.AddProperty( + "PrincipalDerivedAlternateId", + typeof(Guid), + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + principalDerivedAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(int), + valueGenerated: ValueGenerated.OnAdd, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: 0); + id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); + + var details = runtimeEntityType.AddProperty( + "Details", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Details", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_details", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + details.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var number = runtimeEntityType.AddProperty( + "Number", + typeof(int), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Number", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + sentinel: 0); + number.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeArray = runtimeEntityType.AddProperty( + "RefTypeArray", + typeof(IPAddress[]), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeArray", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeEnumerable = runtimeEntityType.AddProperty( + "RefTypeEnumerable", + typeof(IEnumerable), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeEnumerable", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeIList = runtimeEntityType.AddProperty( + "RefTypeIList", + typeof(IList), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeIList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeList = runtimeEntityType.AddProperty( + "RefTypeList", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeArray = runtimeEntityType.AddProperty( + "ValueTypeArray", + typeof(DateTime[]), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeArray", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeEnumerable = runtimeEntityType.AddProperty( + "ValueTypeEnumerable", + typeof(IEnumerable), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeEnumerable", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeIList = runtimeEntityType.AddProperty( + "ValueTypeIList", + typeof(IList), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeList = runtimeEntityType.AddProperty( + "ValueTypeList", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var context = runtimeEntityType.AddServiceProperty( + "Context", + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Context", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + serviceType: typeof(DbContext)); + + var key = runtimeEntityType.AddKey( + new[] { principalDerivedId, principalDerivedAlternateId, id }); + runtimeEntityType.SetPrimaryKey(key); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PrincipalDerivedId"), declaringEntityType.FindProperty("PrincipalDerivedAlternateId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id"), principalEntityType.FindProperty("AlternateId") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + required: true, + ownership: true); + + var manyOwned = principalEntityType.AddNavigation("ManyOwned", + runtimeForeignKey, + onDependent: false, + typeof(ICollection), + fieldInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetField("ManyOwned", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + eagerLoaded: 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", "ManyOwned"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/OwnedTypeEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/OwnedTypeEntityType.cs new file mode 100644 index 000000000..d89b8ae18 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/OwnedTypeEntityType.cs @@ -0,0 +1,227 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class OwnedTypeEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase.Owned#OwnedType", + typeof(CompiledModelTestBase.OwnedType), + baseEntityType, + sharedClrType: true, + changeTrackingStrategy: ChangeTrackingStrategy.ChangingAndChangedNotificationsWithOriginalValues, + propertyCount: 12, + servicePropertyCount: 1, + foreignKeyCount: 2, + keyCount: 1); + + var principalBaseId = runtimeEntityType.AddProperty( + "PrincipalBaseId", + typeof(long), + propertyAccessMode: PropertyAccessMode.Field, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: 0L); + + var overrides = new StoreObjectDictionary(); + var principalBaseIdPrincipalBase = new RuntimeRelationalPropertyOverrides( + principalBaseId, + StoreObjectIdentifier.Table("PrincipalBase", "mySchema"), + false, + null); + overrides.Add(StoreObjectIdentifier.Table("PrincipalBase", "mySchema"), principalBaseIdPrincipalBase); + principalBaseId.AddAnnotation("Relational:RelationalOverrides", overrides); + + principalBaseId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var principalBaseAlternateId = runtimeEntityType.AddProperty( + "PrincipalBaseAlternateId", + typeof(Guid), + propertyAccessMode: PropertyAccessMode.Field, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000")); + principalBaseAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var details = runtimeEntityType.AddProperty( + "Details", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Details", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_details", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + nullable: true); + + var overrides0 = new StoreObjectDictionary(); + var detailsDetails = new RuntimeRelationalPropertyOverrides( + details, + StoreObjectIdentifier.Table("Details", null), + false, + null); + overrides0.Add(StoreObjectIdentifier.Table("Details", null), detailsDetails); + details.AddAnnotation("Relational:RelationalOverrides", overrides0); + + details.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var number = runtimeEntityType.AddProperty( + "Number", + typeof(int), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Number", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + sentinel: 0); + number.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeArray = runtimeEntityType.AddProperty( + "RefTypeArray", + typeof(IPAddress[]), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeArray", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + nullable: true); + refTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeEnumerable = runtimeEntityType.AddProperty( + "RefTypeEnumerable", + typeof(IEnumerable), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeEnumerable", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + nullable: true); + refTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeIList = runtimeEntityType.AddProperty( + "RefTypeIList", + typeof(IList), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeIList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + nullable: true); + refTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeList = runtimeEntityType.AddProperty( + "RefTypeList", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("RefTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_refTypeList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + nullable: true); + refTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeArray = runtimeEntityType.AddProperty( + "ValueTypeArray", + typeof(DateTime[]), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeArray", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + nullable: true); + valueTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeEnumerable = runtimeEntityType.AddProperty( + "ValueTypeEnumerable", + typeof(IEnumerable), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeEnumerable", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + nullable: true); + valueTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeIList = runtimeEntityType.AddProperty( + "ValueTypeIList", + typeof(IList), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + nullable: true); + valueTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeList = runtimeEntityType.AddProperty( + "ValueTypeList", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("ValueTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.OwnedType).GetField("_valueTypeList", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + nullable: true); + valueTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var context = runtimeEntityType.AddServiceProperty( + "Context", + propertyInfo: typeof(CompiledModelTestBase.OwnedType).GetProperty("Context", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + serviceType: typeof(DbContext)); + + var key = runtimeEntityType.AddKey( + new[] { principalBaseId, principalBaseAlternateId }); + runtimeEntityType.SetPrimaryKey(key); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PrincipalBaseId"), declaringEntityType.FindProperty("PrincipalBaseAlternateId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id"), principalEntityType.FindProperty("AlternateId") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + unique: true, + required: true, + requiredDependent: true, + ownership: true); + + var owned = principalEntityType.AddNavigation("Owned", + runtimeForeignKey, + onDependent: false, + typeof(CompiledModelTestBase.OwnedType), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Owned", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("_ownedField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Field, + eagerLoaded: true); + + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PrincipalBaseId"), declaringEntityType.FindProperty("PrincipalBaseAlternateId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("PrincipalBaseId"), principalEntityType.FindProperty("PrincipalBaseAlternateId") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + unique: true, + required: true, + requiredDependent: true); + + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + var fragments = new StoreObjectDictionary(); + var detailsFragment = new RuntimeEntityTypeMappingFragment( + runtimeEntityType, + StoreObjectIdentifier.Table("Details", null), + null); + fragments.Add(StoreObjectIdentifier.Table("Details", null), detailsFragment); + runtimeEntityType.AddAnnotation("Relational:MappingFragments", fragments); + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", "mySchema"); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "PrincipalBase"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/PrincipalBaseEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/PrincipalBaseEntityType.cs new file mode 100644 index 000000000..58f93a460 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/PrincipalBaseEntityType.cs @@ -0,0 +1,251 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using NetTopologySuite.Geometries; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class PrincipalBaseEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", + typeof(CompiledModelTestBase.PrincipalBase), + baseEntityType, + discriminatorValue: "PrincipalBase", + derivedTypesCount: 1, + propertyCount: 17, + navigationCount: 1, + skipNavigationCount: 1, + unnamedIndexCount: 1, + keyCount: 2); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(long?), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + afterSaveBehavior: PropertySaveBehavior.Throw); + + var overrides = new StoreObjectDictionary(); + var idPrincipalDerived = new RuntimeRelationalPropertyOverrides( + id, + StoreObjectIdentifier.Table("PrincipalDerived", null), + true, + "DerivedId"); + overrides.Add(StoreObjectIdentifier.Table("PrincipalDerived", null), idPrincipalDerived); + id.AddAnnotation("Relational:RelationalOverrides", overrides); + + id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var alternateId = runtimeEntityType.AddProperty( + "AlternateId", + typeof(Guid), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("AlternateId", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.FieldDuringConstruction, + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: new Guid("00000000-0000-0000-0000-000000000000"), + jsonValueReaderWriter: JsonGuidReaderWriter.Instance); + alternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum1 = runtimeEntityType.AddProperty( + "Enum1", + typeof(CompiledModelTestBase.AnEnum), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Enum1", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + enum1.SetSentinelFromProviderValue(0); + enum1.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum2 = runtimeEntityType.AddProperty( + "Enum2", + typeof(CompiledModelTestBase.AnEnum?), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Enum2", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + enum2.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var flagsEnum1 = runtimeEntityType.AddProperty( + "FlagsEnum1", + typeof(CompiledModelTestBase.AFlagsEnum), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("FlagsEnum1", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + flagsEnum1.SetSentinelFromProviderValue(0); + flagsEnum1.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var flagsEnum2 = runtimeEntityType.AddProperty( + "FlagsEnum2", + typeof(CompiledModelTestBase.AFlagsEnum), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("FlagsEnum2", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + propertyAccessMode: PropertyAccessMode.Property); + flagsEnum2.SetSentinelFromProviderValue(6); + flagsEnum2.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var point = runtimeEntityType.AddProperty( + "Point", + typeof(Point), + nullable: true, + valueGenerated: ValueGenerated.OnAdd, + valueConverter: new CastingConverter(), + valueComparer: new CompiledModelTestBase.CustomValueComparer(), + providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + point.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + point.AddAnnotation("Relational:ColumnType", "geometry"); + point.AddAnnotation("Relational:DefaultValue", (NetTopologySuite.Geometries.Point)new NetTopologySuite.IO.WKTReader().Read("SRID=0;POINT Z(0 0 0)")); + + var refTypeArray = runtimeEntityType.AddProperty( + "RefTypeArray", + typeof(IPAddress[]), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeEnumerable = runtimeEntityType.AddProperty( + "RefTypeEnumerable", + typeof(IEnumerable), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeIList = runtimeEntityType.AddProperty( + "RefTypeIList", + typeof(IList), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeList = runtimeEntityType.AddProperty( + "RefTypeList", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var stringWithCharSet = runtimeEntityType.AddProperty( + "StringWithCharSet", + typeof(string), + nullable: true, + valueGenerated: ValueGenerated.OnAdd, + valueConverter: new CastingConverter(), + valueComparer: new CompiledModelTestBase.CustomValueComparer(), + providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + stringWithCharSet.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + stringWithCharSet.AddAnnotation("Relational:ColumnType", "varchar(128)"); + stringWithCharSet.AddAnnotation("Relational:DefaultValue", "String having charset"); + + var stringWithCollation = runtimeEntityType.AddProperty( + "StringWithCollation", + typeof(string), + nullable: true, + valueGenerated: ValueGenerated.OnAdd, + valueConverter: new CastingConverter(), + valueComparer: new CompiledModelTestBase.CustomValueComparer(), + providerValueComparer: new CompiledModelTestBase.CustomValueComparer()); + stringWithCollation.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + stringWithCollation.AddAnnotation("Relational:ColumnType", "varchar(128)"); + stringWithCollation.AddAnnotation("Relational:DefaultValue", "String using collation"); + + var valueTypeArray = runtimeEntityType.AddProperty( + "ValueTypeArray", + typeof(DateTime[]), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeEnumerable = runtimeEntityType.AddProperty( + "ValueTypeEnumerable", + typeof(IEnumerable), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeIList = runtimeEntityType.AddProperty( + "ValueTypeIList", + typeof(IList), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeList = runtimeEntityType.AddProperty( + "ValueTypeList", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var key = runtimeEntityType.AddKey( + new[] { id }); + + var key0 = runtimeEntityType.AddKey( + new[] { id, alternateId }); + runtimeEntityType.SetPrimaryKey(key0); + key0.AddAnnotation("Relational:Name", "PK"); + + var index = runtimeEntityType.AddIndex( + new[] { alternateId, id }); + + return runtimeEntityType; + } + + public static RuntimeSkipNavigation CreateSkipNavigation1(RuntimeEntityType declaringEntityType, RuntimeEntityType targetEntityType, RuntimeEntityType joinEntityType) + { + var skipNavigation = declaringEntityType.AddSkipNavigation( + "Deriveds", + targetEntityType, + joinEntityType.FindForeignKey( + new[] { joinEntityType.FindProperty("PrincipalsId"), joinEntityType.FindProperty("PrincipalsAlternateId") }, + declaringEntityType.FindKey(new[] { declaringEntityType.FindProperty("Id"), declaringEntityType.FindProperty("AlternateId") }), + declaringEntityType), + true, + false, + typeof(ICollection), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Deriveds", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + var inverse = targetEntityType.FindSkipNavigation("Principals"); + if (inverse != null) + { + skipNavigation.Inverse = inverse; + inverse.Inverse = skipNavigation; + } + + return skipNavigation; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:MappingStrategy", "TPT"); + runtimeEntityType.AddAnnotation("Relational:Schema", "mySchema"); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "PrincipalBase"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/PrincipalBasePrincipalDerivedDependentBasebyteEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/PrincipalBasePrincipalDerivedDependentBasebyteEntityType.cs new file mode 100644 index 000000000..a59e4ddc8 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/PrincipalBasePrincipalDerivedDependentBasebyteEntityType.cs @@ -0,0 +1,117 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class PrincipalBasePrincipalDerivedDependentBasebyteEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "PrincipalBasePrincipalDerived>", + typeof(Dictionary), + baseEntityType, + sharedClrType: true, + indexerPropertyInfo: RuntimeEntityType.FindIndexerProperty(typeof(Dictionary)), + propertyBag: true, + propertyCount: 5, + foreignKeyCount: 2, + unnamedIndexCount: 1, + keyCount: 1); + + var derivedsId = runtimeEntityType.AddProperty( + "DerivedsId", + typeof(long), + propertyInfo: runtimeEntityType.FindIndexerPropertyInfo(), + afterSaveBehavior: PropertySaveBehavior.Throw); + derivedsId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var derivedsAlternateId = runtimeEntityType.AddProperty( + "DerivedsAlternateId", + typeof(Guid), + propertyInfo: runtimeEntityType.FindIndexerPropertyInfo(), + afterSaveBehavior: PropertySaveBehavior.Throw); + derivedsAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var principalsId = runtimeEntityType.AddProperty( + "PrincipalsId", + typeof(long), + propertyInfo: runtimeEntityType.FindIndexerPropertyInfo(), + afterSaveBehavior: PropertySaveBehavior.Throw); + principalsId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var principalsAlternateId = runtimeEntityType.AddProperty( + "PrincipalsAlternateId", + typeof(Guid), + propertyInfo: runtimeEntityType.FindIndexerPropertyInfo(), + afterSaveBehavior: PropertySaveBehavior.Throw); + principalsAlternateId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var rowid = runtimeEntityType.AddProperty( + "rowid", + typeof(byte[]), + propertyInfo: runtimeEntityType.FindIndexerPropertyInfo(), + nullable: true, + concurrencyToken: true, + valueGenerated: ValueGenerated.OnAddOrUpdate, + beforeSaveBehavior: PropertySaveBehavior.Ignore, + afterSaveBehavior: PropertySaveBehavior.Ignore); + rowid.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var key = runtimeEntityType.AddKey( + new[] { derivedsId, derivedsAlternateId, principalsId, principalsAlternateId }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { principalsId, principalsAlternateId }); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("DerivedsId"), declaringEntityType.FindProperty("DerivedsAlternateId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id"), principalEntityType.FindProperty("AlternateId") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + required: true); + + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PrincipalsId"), declaringEntityType.FindProperty("PrincipalsAlternateId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id"), principalEntityType.FindProperty("AlternateId") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + required: true); + + runtimeForeignKey.AddAnnotation("Relational:Name", "FK_PrincipalBasePrincipalDerived>_Princip~1"); + 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", "PrincipalBasePrincipalDerived>"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/PrincipalDerivedEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/PrincipalDerivedEntityType.cs new file mode 100644 index 000000000..757c5ab18 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/No_NativeAOT/PrincipalDerivedEntityType.cs @@ -0,0 +1,84 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class PrincipalDerivedEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>", + typeof(CompiledModelTestBase.PrincipalDerived>), + baseEntityType, + discriminatorValue: "PrincipalDerived>", + propertyCount: 0, + navigationCount: 2, + skipNavigationCount: 1, + foreignKeyCount: 1); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("Id"), declaringEntityType.FindProperty("AlternateId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id"), principalEntityType.FindProperty("AlternateId") }), + principalEntityType, + deleteBehavior: DeleteBehavior.Cascade, + unique: true, + required: true); + + return runtimeForeignKey; + } + + public static RuntimeSkipNavigation CreateSkipNavigation1(RuntimeEntityType declaringEntityType, RuntimeEntityType targetEntityType, RuntimeEntityType joinEntityType) + { + var skipNavigation = declaringEntityType.AddSkipNavigation( + "Principals", + targetEntityType, + joinEntityType.FindForeignKey( + new[] { joinEntityType.FindProperty("DerivedsId"), joinEntityType.FindProperty("DerivedsAlternateId") }, + declaringEntityType.FindKey(new[] { declaringEntityType.FindProperty("Id"), declaringEntityType.FindProperty("AlternateId") }), + declaringEntityType), + true, + false, + typeof(ICollection), + propertyInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetProperty("Principals", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + var inverse = targetEntityType.FindSkipNavigation("Deriveds"); + if (inverse != null) + { + skipNavigation.Inverse = inverse; + inverse.Inverse = skipNavigation; + } + + return skipNavigation; + } + + 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", "PrincipalDerived"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Sequences/DbContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Sequences/DbContextAssemblyAttributes.cs new file mode 100644 index 000000000..c224873f6 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Sequences/DbContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(DbContext), typeof(DbContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Sequences/DbContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Sequences/DbContextModelBuilder.cs index f2ab9f7d6..ae0eeeb52 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Sequences/DbContextModelBuilder.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Sequences/DbContextModelBuilder.cs @@ -36,7 +36,7 @@ partial void Initialize() AddAnnotation("Relational:Sequences", sequences); AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); AddAnnotation("Relational:MaxIdentifierLength", 64); - AddRuntimeAnnotation("Relational:RelationalModel", CreateRelationalModel()); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); } private IRelationalModel CreateRelationalModel() diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DbContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DbContextAssemblyAttributes.cs new file mode 100644 index 000000000..c224873f6 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DbContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(DbContext), typeof(DbContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DbContextModel.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DbContextModel.cs new file mode 100644 index 000000000..583ee4d90 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DbContextModel.cs @@ -0,0 +1,48 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [DbContext(typeof(DbContext))] + public partial class DbContextModel : RuntimeModel + { + private static readonly bool _useOldBehavior31751 = + System.AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue31751", out var enabled31751) && enabled31751; + + static DbContextModel() + { + var model = new DbContextModel(); + + 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 = (DbContextModel)model.FinalizeModel(); + } + + private static DbContextModel _instance; + public static IModel Instance => _instance; + + partial void Initialize(); + + partial void Customize(); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DbContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DbContextModelBuilder.cs new file mode 100644 index 000000000..e23a63899 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DbContextModelBuilder.cs @@ -0,0 +1,86 @@ +// +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.Update.Internal; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public partial class DbContextModel + { + private DbContextModel() + : base(skipDetectChanges: false, modelId: new Guid("00000000-0000-0000-0000-000000000000"), entityTypeCount: 1) + { + } + + partial void Initialize() + { + var dependentDerived = DependentDerivedEntityType.Create(this); + + DependentDerivedEntityType.CreateAnnotations(dependentDerived); + + AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); + AddAnnotation("Relational:MaxIdentifierLength", 64); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); + } + + private IRelationalModel CreateRelationalModel() + { + var relationalModel = new RelationalModel(this); + + var dependentDerived = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentDerived")!; + + var defaultTableMappings = new List>(); + dependentDerived.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings); + var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentDerived", null, relationalModel); + var dataColumnBase = new ColumnBase("Data", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintTableBase.Columns.Add("Data", dataColumnBase); + var idColumnBase = new ColumnBase("Id", "int", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintTableBase.Columns.Add("Id", idColumnBase); + relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentDerived", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintTableBase); + var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintMappingBase = new TableMappingBase(dependentDerived, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintTableBase, null); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintMappingBase, false); + defaultTableMappings.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase, dependentDerived.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)dataColumnBase, dependentDerived.FindProperty("Data")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentDerivedintMappingBase); + + var tableMappings = new List(); + dependentDerived.SetRuntimeAnnotation("Relational:TableMappings", tableMappings); + var dependentDerivedintTable = new Table("DependentDerived", null, relationalModel); + var idColumn = new Column("Id", "int", dependentDerivedintTable); + dependentDerivedintTable.Columns.Add("Id", idColumn); + idColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn); + var dataColumn = new Column("Data", "longtext", dependentDerivedintTable) + { + IsNullable = true + }; + dependentDerivedintTable.Columns.Add("Data", dataColumn); + dataColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(dataColumn); + relationalModel.Tables.Add(("DependentDerived", null), dependentDerivedintTable); + var dependentDerivedintTableMapping = new TableMapping(dependentDerived, dependentDerivedintTable, null); + dependentDerivedintTable.AddTypeMapping(dependentDerivedintTableMapping, false); + tableMappings.Add(dependentDerivedintTableMapping); + RelationalModel.CreateColumnMapping(idColumn, dependentDerived.FindProperty("Id")!, dependentDerivedintTableMapping); + RelationalModel.CreateColumnMapping(dataColumn, dependentDerived.FindProperty("Data")!, dependentDerivedintTableMapping); + var pK_DependentDerivedint = new UniqueConstraint("PK_DependentDerived", dependentDerivedintTable, new[] { idColumn }); + dependentDerivedintTable.PrimaryKey = pK_DependentDerivedint; + pK_DependentDerivedint.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(pK_DependentDerivedint)); + var pK_DependentDerivedintKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentDerived", + new[] { "Id" }); + pK_DependentDerivedint.MappedKeys.Add(pK_DependentDerivedintKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_DependentDerivedintKey).Add(pK_DependentDerivedint); + dependentDerivedintTable.UniqueConstraints.Add("PK_DependentDerived", pK_DependentDerivedint); + return relationalModel.MakeReadOnly(); + } + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DependentBaseUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DependentBaseUnsafeAccessors.cs new file mode 100644 index 000000000..ae6e17796 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DependentBaseUnsafeAccessors.cs @@ -0,0 +1,15 @@ +// +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DependentBaseUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TKey Id(CompiledModelTestBase.DependentBase @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DependentDerivedEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DependentDerivedEntityType.cs new file mode 100644 index 000000000..c73562e03 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DependentDerivedEntityType.cs @@ -0,0 +1,174 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; +using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage; +using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class DependentDerivedEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentDerived", + typeof(CompiledModelTestBase.DependentDerived), + baseEntityType, + propertyCount: 2, + keyCount: 1); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(int), + propertyInfo: typeof(CompiledModelTestBase.AbstractBase).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.DependentBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + afterSaveBehavior: PropertySaveBehavior.Throw, + sentinel: 0); + id.SetGetter( + int (CompiledModelTestBase.DependentDerived entity) => DependentBaseUnsafeAccessors.Id(entity), + bool (CompiledModelTestBase.DependentDerived entity) => DependentBaseUnsafeAccessors.Id(entity) == 0, + int (CompiledModelTestBase.DependentDerived instance) => DependentBaseUnsafeAccessors.Id(instance), + bool (CompiledModelTestBase.DependentDerived instance) => DependentBaseUnsafeAccessors.Id(instance) == 0); + id.SetSetter( + (CompiledModelTestBase.DependentDerived entity, int value) => DependentBaseUnsafeAccessors.Id(entity) = value); + id.SetMaterializationSetter( + (CompiledModelTestBase.DependentDerived entity, int value) => DependentBaseUnsafeAccessors.Id(entity) = value); + id.SetAccessors( + int (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Id(((CompiledModelTestBase.DependentDerived)(entry.Entity))), + int (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Id(((CompiledModelTestBase.DependentDerived)(entry.Entity))), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 0), + int (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + id.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: -1, + relationshipIndex: 0, + storeGenerationIndex: -1); + id.TypeMapping = MySqlIntTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), + keyComparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), + providerValueComparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); + id.SetCurrentValueComparer(new EntryCurrentValueComparer(id)); + id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var data = runtimeEntityType.AddProperty( + "Data", + typeof(string), + propertyInfo: typeof(CompiledModelTestBase.DependentDerived).GetProperty("Data", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.DependentDerived).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + data.SetGetter( + string (CompiledModelTestBase.DependentDerived entity) => DependentDerivedUnsafeAccessors.Data(entity), + bool (CompiledModelTestBase.DependentDerived entity) => DependentDerivedUnsafeAccessors.Data(entity) == null, + string (CompiledModelTestBase.DependentDerived instance) => DependentDerivedUnsafeAccessors.Data(instance), + bool (CompiledModelTestBase.DependentDerived instance) => DependentDerivedUnsafeAccessors.Data(instance) == null); + data.SetSetter( + (CompiledModelTestBase.DependentDerived entity, string value) => DependentDerivedUnsafeAccessors.Data(entity) = value); + data.SetMaterializationSetter( + (CompiledModelTestBase.DependentDerived entity, string value) => DependentDerivedUnsafeAccessors.Data(entity) = value); + data.SetAccessors( + string (InternalEntityEntry entry) => DependentDerivedUnsafeAccessors.Data(((CompiledModelTestBase.DependentDerived)(entry.Entity))), + string (InternalEntityEntry entry) => DependentDerivedUnsafeAccessors.Data(((CompiledModelTestBase.DependentDerived)(entry.Entity))), + string (InternalEntityEntry entry) => entry.ReadOriginalValue(data, 1), + string (InternalEntityEntry entry) => entry.GetCurrentValue(data), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + data.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + data.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + keyComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + storeTypePostfix: StoreTypePostfix.None); + data.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + return runtimeEntityType; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + var id = runtimeEntityType.FindProperty("Id"); + var data = runtimeEntityType.FindProperty("Data"); + var key = runtimeEntityType.FindKey(new[] { id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateSimpleNonNullableFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory(key)); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.DependentDerived)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id)), (source.GetCurrentValue(data) == null ? null : ((ValueComparer)(((IProperty)data).GetValueComparer())).Snapshot(source.GetCurrentValue(data)))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => Snapshot.Empty); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => Snapshot.Empty); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => Snapshot.Empty); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => Snapshot.Empty); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.DependentDerived)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 2, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 2, + shadowCount: 0, + relationshipCount: 1, + storeGeneratedCount: 0); + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", null); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "DependentDerived"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DependentDerivedUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DependentDerivedUnsafeAccessors.cs new file mode 100644 index 000000000..8847446bf --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/SimpleModel/DependentDerivedUnsafeAccessors.cs @@ -0,0 +1,16 @@ +// +using System; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DependentDerivedUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref string Data(CompiledModelTestBase.DependentDerived @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DbContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DbContextAssemblyAttributes.cs new file mode 100644 index 000000000..c224873f6 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DbContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(DbContext), typeof(DbContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DbContextModel.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DbContextModel.cs new file mode 100644 index 000000000..583ee4d90 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DbContextModel.cs @@ -0,0 +1,48 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [DbContext(typeof(DbContext))] + public partial class DbContextModel : RuntimeModel + { + private static readonly bool _useOldBehavior31751 = + System.AppContext.TryGetSwitch("Microsoft.EntityFrameworkCore.Issue31751", out var enabled31751) && enabled31751; + + static DbContextModel() + { + var model = new DbContextModel(); + + 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 = (DbContextModel)model.FinalizeModel(); + } + + private static DbContextModel _instance; + public static IModel Instance => _instance; + + partial void Initialize(); + + partial void Customize(); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DbContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DbContextModelBuilder.cs new file mode 100644 index 000000000..e8b558d18 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DbContextModelBuilder.cs @@ -0,0 +1,1123 @@ +// +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; +using Microsoft.EntityFrameworkCore.Update.Internal; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public partial class DbContextModel + { + private DbContextModel() + : base(skipDetectChanges: false, modelId: new Guid("00000000-0000-0000-0000-000000000000"), entityTypeCount: 3) + { + } + + partial void Initialize() + { + var dependentBase = DependentBaseEntityType.Create(this); + var principalBase = PrincipalBaseEntityType.Create(this); + var principalDerived = PrincipalDerivedEntityType.Create(this, principalBase); + + DependentBaseEntityType.CreateForeignKey1(dependentBase, principalDerived); + PrincipalBaseEntityType.CreateForeignKey1(principalBase, principalBase); + PrincipalBaseEntityType.CreateForeignKey2(principalBase, principalDerived); + + DependentBaseEntityType.CreateAnnotations(dependentBase); + PrincipalBaseEntityType.CreateAnnotations(principalBase); + PrincipalDerivedEntityType.CreateAnnotations(principalDerived); + + AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); + AddAnnotation("Relational:DefaultSchema", "TPC"); + AddAnnotation("Relational:MaxIdentifierLength", 64); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); + } + + private IRelationalModel CreateRelationalModel() + { + var relationalModel = new RelationalModel(this); + + var dependentBase = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase")!; + + var defaultTableMappings = new List>(); + dependentBase.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings); + var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", null, relationalModel); + var idColumnBase = new ColumnBase("Id", "tinyint unsigned", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("Id", idColumnBase); + var principalIdColumnBase = new ColumnBase("PrincipalId", "bigint", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("PrincipalId", principalIdColumnBase); + relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase); + var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase = new TableMappingBase(dependentBase, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase, null); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase, false); + defaultTableMappings.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase, dependentBase.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)principalIdColumnBase, dependentBase.FindProperty("PrincipalId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + + var tableMappings = new List(); + dependentBase.SetRuntimeAnnotation("Relational:TableMappings", tableMappings); + var dependentBasebyteTable = new Table("DependentBase", "TPC", relationalModel); + var idColumn = new Column("Id", "tinyint unsigned", dependentBasebyteTable); + dependentBasebyteTable.Columns.Add("Id", idColumn); + idColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn); + var principalIdColumn = new Column("PrincipalId", "bigint", dependentBasebyteTable) + { + IsNullable = true + }; + dependentBasebyteTable.Columns.Add("PrincipalId", principalIdColumn); + principalIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalIdColumn); + relationalModel.Tables.Add(("DependentBase", "TPC"), dependentBasebyteTable); + var dependentBasebyteTableMapping = new TableMapping(dependentBase, dependentBasebyteTable, null); + dependentBasebyteTable.AddTypeMapping(dependentBasebyteTableMapping, false); + tableMappings.Add(dependentBasebyteTableMapping); + RelationalModel.CreateColumnMapping(idColumn, dependentBase.FindProperty("Id")!, dependentBasebyteTableMapping); + RelationalModel.CreateColumnMapping(principalIdColumn, dependentBase.FindProperty("PrincipalId")!, dependentBasebyteTableMapping); + var pK_DependentBasebyte = new UniqueConstraint("PK_DependentBase", dependentBasebyteTable, new[] { idColumn }); + dependentBasebyteTable.PrimaryKey = pK_DependentBasebyte; + pK_DependentBasebyte.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(pK_DependentBasebyte)); + var pK_DependentBasebyteKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", + new[] { "Id" }); + pK_DependentBasebyte.MappedKeys.Add(pK_DependentBasebyteKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_DependentBasebyteKey).Add(pK_DependentBasebyte); + dependentBasebyteTable.UniqueConstraints.Add("PK_DependentBase", pK_DependentBasebyte); + var iX_DependentBasebyte_PrincipalId = new TableIndex( + "IX_DependentBase_PrincipalId", dependentBasebyteTable, new[] { principalIdColumn }, true); + iX_DependentBasebyte_PrincipalId.SetRowIndexValueFactory(new SimpleRowIndexValueFactory(iX_DependentBasebyte_PrincipalId)); + var iX_DependentBasebyte_PrincipalIdIx = RelationalModel.GetIndex(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", + new[] { "PrincipalId" }); + iX_DependentBasebyte_PrincipalId.MappedIndexes.Add(iX_DependentBasebyte_PrincipalIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_DependentBasebyte_PrincipalIdIx).Add(iX_DependentBasebyte_PrincipalId); + dependentBasebyteTable.Indexes.Add("IX_DependentBase_PrincipalId", iX_DependentBasebyte_PrincipalId); + + var principalBase = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase")!; + + var defaultTableMappings0 = new List>(); + principalBase.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings0); + var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", null, relationalModel); + var enum1ColumnBase = new ColumnBase("Enum1", "int", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("Enum1", enum1ColumnBase); + var enum2ColumnBase = new ColumnBase("Enum2", "int", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("Enum2", enum2ColumnBase); + var flagsEnum1ColumnBase = new ColumnBase("FlagsEnum1", "int", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("FlagsEnum1", flagsEnum1ColumnBase); + var flagsEnum2ColumnBase = new ColumnBase("FlagsEnum2", "int", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("FlagsEnum2", flagsEnum2ColumnBase); + var idColumnBase0 = new ColumnBase("Id", "bigint", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("Id", idColumnBase0); + var principalBaseIdColumnBase = new ColumnBase("PrincipalBaseId", "bigint", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("PrincipalBaseId", principalBaseIdColumnBase); + var principalDerivedDependentBasebyteIdColumnBase = new ColumnBase("PrincipalDerived>Id", "bigint", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("PrincipalDerived>Id", principalDerivedDependentBasebyteIdColumnBase); + var refTypeArrayColumnBase = new ColumnBase("RefTypeArray", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("RefTypeArray", refTypeArrayColumnBase); + var refTypeEnumerableColumnBase = new ColumnBase("RefTypeEnumerable", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumnBase); + var refTypeIListColumnBase = new ColumnBase("RefTypeIList", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("RefTypeIList", refTypeIListColumnBase); + var refTypeListColumnBase = new ColumnBase("RefTypeList", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("RefTypeList", refTypeListColumnBase); + var valueTypeArrayColumnBase = new ColumnBase("ValueTypeArray", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("ValueTypeArray", valueTypeArrayColumnBase); + var valueTypeEnumerableColumnBase = new ColumnBase("ValueTypeEnumerable", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumnBase); + var valueTypeIListColumnBase = new ColumnBase("ValueTypeIList", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("ValueTypeIList", valueTypeIListColumnBase); + var valueTypeListColumnBase = new ColumnBase("ValueTypeList", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.Columns.Add("ValueTypeList", valueTypeListColumnBase); + relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase); + var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase = new TableMappingBase(principalBase, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase, false); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase, false); + defaultTableMappings0.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase0, principalBase.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)enum1ColumnBase, principalBase.FindProperty("Enum1")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)enum2ColumnBase, principalBase.FindProperty("Enum2")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)flagsEnum1ColumnBase, principalBase.FindProperty("FlagsEnum1")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)flagsEnum2ColumnBase, principalBase.FindProperty("FlagsEnum2")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)principalBaseIdColumnBase, principalBase.FindProperty("PrincipalBaseId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)principalDerivedDependentBasebyteIdColumnBase, principalBase.FindProperty("PrincipalDerivedId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)refTypeArrayColumnBase, principalBase.FindProperty("RefTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)refTypeEnumerableColumnBase, principalBase.FindProperty("RefTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)refTypeIListColumnBase, principalBase.FindProperty("RefTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)refTypeListColumnBase, principalBase.FindProperty("RefTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)valueTypeArrayColumnBase, principalBase.FindProperty("ValueTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)valueTypeEnumerableColumnBase, principalBase.FindProperty("ValueTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)valueTypeIListColumnBase, principalBase.FindProperty("ValueTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)valueTypeListColumnBase, principalBase.FindProperty("ValueTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalBaseMappingBase); + + var tableMappings0 = new List(); + principalBase.SetRuntimeAnnotation("Relational:TableMappings", tableMappings0); + var principalBaseTable = new Table("PrincipalBase", "TPC", relationalModel); + var idColumn0 = new Column("Id", "bigint", principalBaseTable); + principalBaseTable.Columns.Add("Id", idColumn0); + idColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn0); + var enum1Column = new Column("Enum1", "int", principalBaseTable); + principalBaseTable.Columns.Add("Enum1", enum1Column); + enum1Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enum1Column); + var enum2Column = new Column("Enum2", "int", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("Enum2", enum2Column); + enum2Column.Accessors = ColumnAccessorsFactory.CreateGeneric(enum2Column); + var flagsEnum1Column = new Column("FlagsEnum1", "int", principalBaseTable); + principalBaseTable.Columns.Add("FlagsEnum1", flagsEnum1Column); + flagsEnum1Column.Accessors = ColumnAccessorsFactory.CreateGeneric(flagsEnum1Column); + var flagsEnum2Column = new Column("FlagsEnum2", "int", principalBaseTable); + principalBaseTable.Columns.Add("FlagsEnum2", flagsEnum2Column); + flagsEnum2Column.Accessors = ColumnAccessorsFactory.CreateGeneric(flagsEnum2Column); + var principalBaseIdColumn = new Column("PrincipalBaseId", "bigint", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("PrincipalBaseId", principalBaseIdColumn); + principalBaseIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalBaseIdColumn); + var principalDerivedDependentBasebyteIdColumn = new Column("PrincipalDerived>Id", "bigint", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("PrincipalDerived>Id", principalDerivedDependentBasebyteIdColumn); + principalDerivedDependentBasebyteIdColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(principalDerivedDependentBasebyteIdColumn); + var refTypeArrayColumn = new Column("RefTypeArray", "longtext", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("RefTypeArray", refTypeArrayColumn); + refTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeArrayColumn); + var refTypeEnumerableColumn = new Column("RefTypeEnumerable", "longtext", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumn); + refTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeEnumerableColumn); + var refTypeIListColumn = new Column("RefTypeIList", "longtext", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("RefTypeIList", refTypeIListColumn); + refTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeIListColumn); + var refTypeListColumn = new Column("RefTypeList", "longtext", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("RefTypeList", refTypeListColumn); + refTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeListColumn); + var valueTypeArrayColumn = new Column("ValueTypeArray", "longtext", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("ValueTypeArray", valueTypeArrayColumn); + valueTypeArrayColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeArrayColumn); + var valueTypeEnumerableColumn = new Column("ValueTypeEnumerable", "longtext", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumn); + valueTypeEnumerableColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeEnumerableColumn); + var valueTypeIListColumn = new Column("ValueTypeIList", "longtext", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("ValueTypeIList", valueTypeIListColumn); + valueTypeIListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeIListColumn); + var valueTypeListColumn = new Column("ValueTypeList", "longtext", principalBaseTable) + { + IsNullable = true + }; + principalBaseTable.Columns.Add("ValueTypeList", valueTypeListColumn); + valueTypeListColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeListColumn); + relationalModel.Tables.Add(("PrincipalBase", "TPC"), principalBaseTable); + var principalBaseTableMapping = new TableMapping(principalBase, principalBaseTable, false); + principalBaseTable.AddTypeMapping(principalBaseTableMapping, false); + tableMappings0.Add(principalBaseTableMapping); + RelationalModel.CreateColumnMapping(idColumn0, principalBase.FindProperty("Id")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(enum1Column, principalBase.FindProperty("Enum1")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(enum2Column, principalBase.FindProperty("Enum2")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(flagsEnum1Column, principalBase.FindProperty("FlagsEnum1")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(flagsEnum2Column, principalBase.FindProperty("FlagsEnum2")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(principalBaseIdColumn, principalBase.FindProperty("PrincipalBaseId")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(principalDerivedDependentBasebyteIdColumn, principalBase.FindProperty("PrincipalDerivedId")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(refTypeArrayColumn, principalBase.FindProperty("RefTypeArray")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(refTypeEnumerableColumn, principalBase.FindProperty("RefTypeEnumerable")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(refTypeIListColumn, principalBase.FindProperty("RefTypeIList")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(refTypeListColumn, principalBase.FindProperty("RefTypeList")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(valueTypeArrayColumn, principalBase.FindProperty("ValueTypeArray")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(valueTypeEnumerableColumn, principalBase.FindProperty("ValueTypeEnumerable")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(valueTypeIListColumn, principalBase.FindProperty("ValueTypeIList")!, principalBaseTableMapping); + RelationalModel.CreateColumnMapping(valueTypeListColumn, principalBase.FindProperty("ValueTypeList")!, principalBaseTableMapping); + var pK_PrincipalBase = new UniqueConstraint("PK_PrincipalBase", principalBaseTable, new[] { idColumn0 }); + principalBaseTable.PrimaryKey = pK_PrincipalBase; + pK_PrincipalBase.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(pK_PrincipalBase)); + var pK_PrincipalBaseKey = RelationalModel.GetKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", + new[] { "Id" }); + pK_PrincipalBase.MappedKeys.Add(pK_PrincipalBaseKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_PrincipalBaseKey).Add(pK_PrincipalBase); + principalBaseTable.UniqueConstraints.Add("PK_PrincipalBase", pK_PrincipalBase); + var iX_PrincipalBase_PrincipalDerivedDependentBasebyteId = new TableIndex( + "IX_PrincipalBase_PrincipalDerived>Id", principalBaseTable, new[] { principalDerivedDependentBasebyteIdColumn }, false); + iX_PrincipalBase_PrincipalDerivedDependentBasebyteId.SetRowIndexValueFactory(new SimpleRowIndexValueFactory(iX_PrincipalBase_PrincipalDerivedDependentBasebyteId)); + var iX_PrincipalBase_PrincipalDerivedDependentBasebyteIdIx = RelationalModel.GetIndex(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", + new[] { "PrincipalDerivedId" }); + iX_PrincipalBase_PrincipalDerivedDependentBasebyteId.MappedIndexes.Add(iX_PrincipalBase_PrincipalDerivedDependentBasebyteIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_PrincipalBase_PrincipalDerivedDependentBasebyteIdIx).Add(iX_PrincipalBase_PrincipalDerivedDependentBasebyteId); + principalBaseTable.Indexes.Add("IX_PrincipalBase_PrincipalDerived>Id", iX_PrincipalBase_PrincipalDerivedDependentBasebyteId); + var pIX = new TableIndex( + "PIX", principalBaseTable, new[] { principalBaseIdColumn }, true); + pIX.SetRowIndexValueFactory(new SimpleRowIndexValueFactory(pIX)); + var pIXIx = RelationalModel.GetIndex(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", + "PrincipalIndex"); + pIX.MappedIndexes.Add(pIXIx); + RelationalModel.GetOrCreateTableIndexes(pIXIx).Add(pIX); + principalBaseTable.Indexes.Add("PIX", pIX); + + var viewMappings = new List(); + principalBase.SetRuntimeAnnotation("Relational:ViewMappings", viewMappings); + var principalBaseViewView = new View("PrincipalBaseView", "TPC", relationalModel); + var enum1ViewColumn = new ViewColumn("Enum1", "int", principalBaseViewView); + principalBaseViewView.Columns.Add("Enum1", enum1ViewColumn); + var enum2ViewColumn = new ViewColumn("Enum2", "int", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("Enum2", enum2ViewColumn); + var flagsEnum1ViewColumn = new ViewColumn("FlagsEnum1", "int", principalBaseViewView); + principalBaseViewView.Columns.Add("FlagsEnum1", flagsEnum1ViewColumn); + var flagsEnum2ViewColumn = new ViewColumn("FlagsEnum2", "int", principalBaseViewView); + principalBaseViewView.Columns.Add("FlagsEnum2", flagsEnum2ViewColumn); + var idViewColumn = new ViewColumn("Id", "bigint", principalBaseViewView); + principalBaseViewView.Columns.Add("Id", idViewColumn); + var principalBaseIdViewColumn = new ViewColumn("PrincipalBaseId", "bigint", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("PrincipalBaseId", principalBaseIdViewColumn); + var principalDerivedIdViewColumn = new ViewColumn("PrincipalDerivedId", "bigint", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("PrincipalDerivedId", principalDerivedIdViewColumn); + var refTypeArrayViewColumn = new ViewColumn("RefTypeArray", "longtext", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("RefTypeArray", refTypeArrayViewColumn); + var refTypeEnumerableViewColumn = new ViewColumn("RefTypeEnumerable", "longtext", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("RefTypeEnumerable", refTypeEnumerableViewColumn); + var refTypeIListViewColumn = new ViewColumn("RefTypeIList", "longtext", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("RefTypeIList", refTypeIListViewColumn); + var refTypeListViewColumn = new ViewColumn("RefTypeList", "longtext", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("RefTypeList", refTypeListViewColumn); + var valueTypeArrayViewColumn = new ViewColumn("ValueTypeArray", "longtext", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("ValueTypeArray", valueTypeArrayViewColumn); + var valueTypeEnumerableViewColumn = new ViewColumn("ValueTypeEnumerable", "longtext", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableViewColumn); + var valueTypeIListViewColumn = new ViewColumn("ValueTypeIList", "longtext", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("ValueTypeIList", valueTypeIListViewColumn); + var valueTypeListViewColumn = new ViewColumn("ValueTypeList", "longtext", principalBaseViewView) + { + IsNullable = true + }; + principalBaseViewView.Columns.Add("ValueTypeList", valueTypeListViewColumn); + relationalModel.Views.Add(("PrincipalBaseView", "TPC"), principalBaseViewView); + var principalBaseViewViewMapping = new ViewMapping(principalBase, principalBaseViewView, false); + principalBaseViewView.AddTypeMapping(principalBaseViewViewMapping, false); + viewMappings.Add(principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(idViewColumn, principalBase.FindProperty("Id")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(enum1ViewColumn, principalBase.FindProperty("Enum1")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(enum2ViewColumn, principalBase.FindProperty("Enum2")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(flagsEnum1ViewColumn, principalBase.FindProperty("FlagsEnum1")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(flagsEnum2ViewColumn, principalBase.FindProperty("FlagsEnum2")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(principalBaseIdViewColumn, principalBase.FindProperty("PrincipalBaseId")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(principalDerivedIdViewColumn, principalBase.FindProperty("PrincipalDerivedId")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(refTypeArrayViewColumn, principalBase.FindProperty("RefTypeArray")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(refTypeEnumerableViewColumn, principalBase.FindProperty("RefTypeEnumerable")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(refTypeIListViewColumn, principalBase.FindProperty("RefTypeIList")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(refTypeListViewColumn, principalBase.FindProperty("RefTypeList")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(valueTypeArrayViewColumn, principalBase.FindProperty("ValueTypeArray")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(valueTypeEnumerableViewColumn, principalBase.FindProperty("ValueTypeEnumerable")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(valueTypeIListViewColumn, principalBase.FindProperty("ValueTypeIList")!, principalBaseViewViewMapping); + RelationalModel.CreateViewColumnMapping(valueTypeListViewColumn, principalBase.FindProperty("ValueTypeList")!, principalBaseViewViewMapping); + + var deleteSprocMappings = new List(); + principalBase.SetRuntimeAnnotation("Relational:DeleteStoredProcedureMappings", deleteSprocMappings); + var principalBase_DeleteStoreSproc = new StoreStoredProcedure("PrincipalBase_Delete", "TPC", relationalModel); + var id_OriginalParameter = new StoreStoredProcedureParameter("Id_Original", "bigint", 0, principalBase_DeleteStoreSproc, System.Data.ParameterDirection.Input); + principalBase_DeleteStoreSproc.AddParameter(id_OriginalParameter); + var rowsAffectedParameter = new StoreStoredProcedureParameter("RowsAffected", "int", 1, principalBase_DeleteStoreSproc, System.Data.ParameterDirection.Output); + principalBase_DeleteStoreSproc.AddParameter(rowsAffectedParameter); + principalBase_DeleteStoreSproc.AddStoredProcedure((IRuntimeStoredProcedure)principalBase.GetDeleteStoredProcedure()!); + relationalModel.StoredProcedures.Add(("PrincipalBase_Delete", "TPC"), principalBase_DeleteStoreSproc); + var principalBase_DeleteDSproc = (IRuntimeStoredProcedure)principalBase.GetDeleteStoredProcedure()!; + var principalBase_DeleteSprocMapping = new StoredProcedureMapping(principalBase, principalBase_DeleteStoreSproc, principalBase_DeleteDSproc, principalBaseTableMapping, false); + principalBase_DeleteStoreSproc.AddTypeMapping(principalBase_DeleteSprocMapping, false); + deleteSprocMappings.Add(principalBase_DeleteSprocMapping); + principalBaseTableMapping.DeleteStoredProcedureMapping = principalBase_DeleteSprocMapping; + RelationalModel.CreateStoredProcedureParameterMapping(id_OriginalParameter, principalBase_DeleteDSproc.FindParameter("Id_Original")!, principalBase.FindProperty("Id")!, principalBase_DeleteSprocMapping); + + var insertSprocMappings = new List(); + principalBase.SetRuntimeAnnotation("Relational:InsertStoredProcedureMappings", insertSprocMappings); + var principalBase_InsertStoreSproc = new StoreStoredProcedure("PrincipalBase_Insert", "TPC", relationalModel); + var idParameter = new StoreStoredProcedureParameter("Id", "bigint", 0, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input); + principalBase_InsertStoreSproc.AddParameter(idParameter); + var principalBaseIdParameter = new StoreStoredProcedureParameter("PrincipalBaseId", "bigint", 1, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(principalBaseIdParameter); + var principalDerivedIdParameter = new StoreStoredProcedureParameter("PrincipalDerivedId", "bigint", 2, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(principalDerivedIdParameter); + var enum2Parameter = new StoreStoredProcedureParameter("Enum2", "int", 3, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(enum2Parameter); + var flagsEnum1Parameter = new StoreStoredProcedureParameter("FlagsEnum1", "int", 4, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input); + principalBase_InsertStoreSproc.AddParameter(flagsEnum1Parameter); + var flagsEnum2Parameter = new StoreStoredProcedureParameter("FlagsEnum2", "int", 5, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input); + principalBase_InsertStoreSproc.AddParameter(flagsEnum2Parameter); + var valueTypeListParameter = new StoreStoredProcedureParameter("ValueTypeList", "longtext", 6, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(valueTypeListParameter); + var valueTypeIListParameter = new StoreStoredProcedureParameter("ValueTypeIList", "longtext", 7, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(valueTypeIListParameter); + var valueTypeArrayParameter = new StoreStoredProcedureParameter("ValueTypeArray", "longtext", 8, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(valueTypeArrayParameter); + var valueTypeEnumerableParameter = new StoreStoredProcedureParameter("ValueTypeEnumerable", "longtext", 9, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(valueTypeEnumerableParameter); + var refTypeListParameter = new StoreStoredProcedureParameter("RefTypeList", "longtext", 10, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(refTypeListParameter); + var refTypeIListParameter = new StoreStoredProcedureParameter("RefTypeIList", "longtext", 11, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(refTypeIListParameter); + var refTypeArrayParameter = new StoreStoredProcedureParameter("RefTypeArray", "longtext", 12, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(refTypeArrayParameter); + var refTypeEnumerableParameter = new StoreStoredProcedureParameter("RefTypeEnumerable", "longtext", 13, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_InsertStoreSproc.AddParameter(refTypeEnumerableParameter); + var baseEnumParameter = new StoreStoredProcedureParameter("BaseEnum", "int", 14, principalBase_InsertStoreSproc, System.Data.ParameterDirection.Output); + principalBase_InsertStoreSproc.AddParameter(baseEnumParameter); + principalBase_InsertStoreSproc.AddStoredProcedure((IRuntimeStoredProcedure)principalBase.GetInsertStoredProcedure()!); + relationalModel.StoredProcedures.Add(("PrincipalBase_Insert", "TPC"), principalBase_InsertStoreSproc); + var principalBase_InsertISproc = (IRuntimeStoredProcedure)principalBase.GetInsertStoredProcedure()!; + var principalBase_InsertSprocMapping = new StoredProcedureMapping(principalBase, principalBase_InsertStoreSproc, principalBase_InsertISproc, principalBaseTableMapping, false); + principalBase_InsertStoreSproc.AddTypeMapping(principalBase_InsertSprocMapping, false); + insertSprocMappings.Add(principalBase_InsertSprocMapping); + principalBaseTableMapping.InsertStoredProcedureMapping = principalBase_InsertSprocMapping; + RelationalModel.CreateStoredProcedureParameterMapping(idParameter, principalBase_InsertISproc.FindParameter("Id")!, principalBase.FindProperty("Id")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(baseEnumParameter, principalBase_InsertISproc.FindParameter("BaseEnum")!, principalBase.FindProperty("Enum1")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(enum2Parameter, principalBase_InsertISproc.FindParameter("Enum2")!, principalBase.FindProperty("Enum2")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(flagsEnum1Parameter, principalBase_InsertISproc.FindParameter("FlagsEnum1")!, principalBase.FindProperty("FlagsEnum1")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(flagsEnum2Parameter, principalBase_InsertISproc.FindParameter("FlagsEnum2")!, principalBase.FindProperty("FlagsEnum2")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(principalBaseIdParameter, principalBase_InsertISproc.FindParameter("PrincipalBaseId")!, principalBase.FindProperty("PrincipalBaseId")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(principalDerivedIdParameter, principalBase_InsertISproc.FindParameter("PrincipalDerivedId")!, principalBase.FindProperty("PrincipalDerivedId")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeArrayParameter, principalBase_InsertISproc.FindParameter("RefTypeArray")!, principalBase.FindProperty("RefTypeArray")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeEnumerableParameter, principalBase_InsertISproc.FindParameter("RefTypeEnumerable")!, principalBase.FindProperty("RefTypeEnumerable")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeIListParameter, principalBase_InsertISproc.FindParameter("RefTypeIList")!, principalBase.FindProperty("RefTypeIList")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeListParameter, principalBase_InsertISproc.FindParameter("RefTypeList")!, principalBase.FindProperty("RefTypeList")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeArrayParameter, principalBase_InsertISproc.FindParameter("ValueTypeArray")!, principalBase.FindProperty("ValueTypeArray")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeEnumerableParameter, principalBase_InsertISproc.FindParameter("ValueTypeEnumerable")!, principalBase.FindProperty("ValueTypeEnumerable")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeIListParameter, principalBase_InsertISproc.FindParameter("ValueTypeIList")!, principalBase.FindProperty("ValueTypeIList")!, principalBase_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeListParameter, principalBase_InsertISproc.FindParameter("ValueTypeList")!, principalBase.FindProperty("ValueTypeList")!, principalBase_InsertSprocMapping); + + var updateSprocMappings = new List(); + principalBase.SetRuntimeAnnotation("Relational:UpdateStoredProcedureMappings", updateSprocMappings); + var principalBase_UpdateStoreSproc = new StoreStoredProcedure("PrincipalBase_Update", "TPC", relationalModel); + var principalBaseIdParameter0 = new StoreStoredProcedureParameter("PrincipalBaseId", "bigint", 0, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(principalBaseIdParameter0); + var principalDerivedIdParameter0 = new StoreStoredProcedureParameter("PrincipalDerivedId", "bigint", 1, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(principalDerivedIdParameter0); + var enum1Parameter = new StoreStoredProcedureParameter("Enum1", "int", 2, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input); + principalBase_UpdateStoreSproc.AddParameter(enum1Parameter); + var enum2Parameter0 = new StoreStoredProcedureParameter("Enum2", "int", 3, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(enum2Parameter0); + var flagsEnum1Parameter0 = new StoreStoredProcedureParameter("FlagsEnum1", "int", 4, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input); + principalBase_UpdateStoreSproc.AddParameter(flagsEnum1Parameter0); + var flagsEnum2Parameter0 = new StoreStoredProcedureParameter("FlagsEnum2", "int", 5, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input); + principalBase_UpdateStoreSproc.AddParameter(flagsEnum2Parameter0); + var valueTypeListParameter0 = new StoreStoredProcedureParameter("ValueTypeList", "longtext", 6, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(valueTypeListParameter0); + var valueTypeIListParameter0 = new StoreStoredProcedureParameter("ValueTypeIList", "longtext", 7, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(valueTypeIListParameter0); + var valueTypeArrayParameter0 = new StoreStoredProcedureParameter("ValueTypeArray", "longtext", 8, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(valueTypeArrayParameter0); + var valueTypeEnumerableParameter0 = new StoreStoredProcedureParameter("ValueTypeEnumerable", "longtext", 9, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(valueTypeEnumerableParameter0); + var refTypeListParameter0 = new StoreStoredProcedureParameter("RefTypeList", "longtext", 10, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(refTypeListParameter0); + var refTypeIListParameter0 = new StoreStoredProcedureParameter("RefTypeIList", "longtext", 11, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(refTypeIListParameter0); + var refTypeArrayParameter0 = new StoreStoredProcedureParameter("RefTypeArray", "longtext", 12, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(refTypeArrayParameter0); + var refTypeEnumerableParameter0 = new StoreStoredProcedureParameter("RefTypeEnumerable", "longtext", 13, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + principalBase_UpdateStoreSproc.AddParameter(refTypeEnumerableParameter0); + var id_OriginalParameter0 = new StoreStoredProcedureParameter("Id_Original", "bigint", 14, principalBase_UpdateStoreSproc, System.Data.ParameterDirection.Input); + principalBase_UpdateStoreSproc.AddParameter(id_OriginalParameter0); + principalBase_UpdateStoreSproc.AddStoredProcedure((IRuntimeStoredProcedure)principalBase.GetUpdateStoredProcedure()!); + relationalModel.StoredProcedures.Add(("PrincipalBase_Update", "TPC"), principalBase_UpdateStoreSproc); + var principalBase_UpdateUSproc = (IRuntimeStoredProcedure)principalBase.GetUpdateStoredProcedure()!; + var principalBase_UpdateSprocMapping = new StoredProcedureMapping(principalBase, principalBase_UpdateStoreSproc, principalBase_UpdateUSproc, principalBaseTableMapping, false); + principalBase_UpdateStoreSproc.AddTypeMapping(principalBase_UpdateSprocMapping, false); + updateSprocMappings.Add(principalBase_UpdateSprocMapping); + principalBaseTableMapping.UpdateStoredProcedureMapping = principalBase_UpdateSprocMapping; + RelationalModel.CreateStoredProcedureParameterMapping(id_OriginalParameter0, principalBase_UpdateUSproc.FindParameter("Id_Original")!, principalBase.FindProperty("Id")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(enum1Parameter, principalBase_UpdateUSproc.FindParameter("Enum1")!, principalBase.FindProperty("Enum1")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(enum2Parameter0, principalBase_UpdateUSproc.FindParameter("Enum2")!, principalBase.FindProperty("Enum2")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(flagsEnum1Parameter0, principalBase_UpdateUSproc.FindParameter("FlagsEnum1")!, principalBase.FindProperty("FlagsEnum1")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(flagsEnum2Parameter0, principalBase_UpdateUSproc.FindParameter("FlagsEnum2")!, principalBase.FindProperty("FlagsEnum2")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(principalBaseIdParameter0, principalBase_UpdateUSproc.FindParameter("PrincipalBaseId")!, principalBase.FindProperty("PrincipalBaseId")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(principalDerivedIdParameter0, principalBase_UpdateUSproc.FindParameter("PrincipalDerivedId")!, principalBase.FindProperty("PrincipalDerivedId")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeArrayParameter0, principalBase_UpdateUSproc.FindParameter("RefTypeArray")!, principalBase.FindProperty("RefTypeArray")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeEnumerableParameter0, principalBase_UpdateUSproc.FindParameter("RefTypeEnumerable")!, principalBase.FindProperty("RefTypeEnumerable")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeIListParameter0, principalBase_UpdateUSproc.FindParameter("RefTypeIList")!, principalBase.FindProperty("RefTypeIList")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeListParameter0, principalBase_UpdateUSproc.FindParameter("RefTypeList")!, principalBase.FindProperty("RefTypeList")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeArrayParameter0, principalBase_UpdateUSproc.FindParameter("ValueTypeArray")!, principalBase.FindProperty("ValueTypeArray")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeEnumerableParameter0, principalBase_UpdateUSproc.FindParameter("ValueTypeEnumerable")!, principalBase.FindProperty("ValueTypeEnumerable")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeIListParameter0, principalBase_UpdateUSproc.FindParameter("ValueTypeIList")!, principalBase.FindProperty("ValueTypeIList")!, principalBase_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeListParameter0, principalBase_UpdateUSproc.FindParameter("ValueTypeList")!, principalBase.FindProperty("ValueTypeList")!, principalBase_UpdateSprocMapping); + + var principalDerived = FindEntityType("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>")!; + + var defaultTableMappings1 = new List>(); + principalDerived.SetRuntimeAnnotation("Relational:DefaultMappings", defaultTableMappings1); + var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase = new TableBase("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>", null, relationalModel); + var enum1ColumnBase0 = new ColumnBase("Enum1", "int", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("Enum1", enum1ColumnBase0); + var enum2ColumnBase0 = new ColumnBase("Enum2", "int", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("Enum2", enum2ColumnBase0); + var flagsEnum1ColumnBase0 = new ColumnBase("FlagsEnum1", "int", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("FlagsEnum1", flagsEnum1ColumnBase0); + var flagsEnum2ColumnBase0 = new ColumnBase("FlagsEnum2", "int", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("FlagsEnum2", flagsEnum2ColumnBase0); + var idColumnBase1 = new ColumnBase("Id", "bigint", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("Id", idColumnBase1); + var principalBaseIdColumnBase0 = new ColumnBase("PrincipalBaseId", "bigint", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("PrincipalBaseId", principalBaseIdColumnBase0); + var principalDerivedDependentBasebyteIdColumnBase0 = new ColumnBase("PrincipalDerived>Id", "bigint", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("PrincipalDerived>Id", principalDerivedDependentBasebyteIdColumnBase0); + var refTypeArrayColumnBase0 = new ColumnBase("RefTypeArray", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("RefTypeArray", refTypeArrayColumnBase0); + var refTypeEnumerableColumnBase0 = new ColumnBase("RefTypeEnumerable", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumnBase0); + var refTypeIListColumnBase0 = new ColumnBase("RefTypeIList", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("RefTypeIList", refTypeIListColumnBase0); + var refTypeListColumnBase0 = new ColumnBase("RefTypeList", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("RefTypeList", refTypeListColumnBase0); + var valueTypeArrayColumnBase0 = new ColumnBase("ValueTypeArray", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("ValueTypeArray", valueTypeArrayColumnBase0); + var valueTypeEnumerableColumnBase0 = new ColumnBase("ValueTypeEnumerable", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumnBase0); + var valueTypeIListColumnBase0 = new ColumnBase("ValueTypeIList", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("ValueTypeIList", valueTypeIListColumnBase0); + var valueTypeListColumnBase0 = new ColumnBase("ValueTypeList", "longtext", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase) + { + IsNullable = true + }; + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.Columns.Add("ValueTypeList", valueTypeListColumnBase0); + relationalModel.DefaultTables.Add("Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>", microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase); + var microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase = new TableMappingBase(principalDerived, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase, null); + microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteTableBase.AddTypeMapping(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase, false); + defaultTableMappings1.Add(microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)idColumnBase1, principalDerived.FindProperty("Id")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)enum1ColumnBase0, principalDerived.FindProperty("Enum1")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)enum2ColumnBase0, principalDerived.FindProperty("Enum2")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)flagsEnum1ColumnBase0, principalDerived.FindProperty("FlagsEnum1")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)flagsEnum2ColumnBase0, principalDerived.FindProperty("FlagsEnum2")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)principalBaseIdColumnBase0, principalDerived.FindProperty("PrincipalBaseId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)principalDerivedDependentBasebyteIdColumnBase0, principalDerived.FindProperty("PrincipalDerivedId")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)refTypeArrayColumnBase0, principalDerived.FindProperty("RefTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)refTypeEnumerableColumnBase0, principalDerived.FindProperty("RefTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)refTypeIListColumnBase0, principalDerived.FindProperty("RefTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)refTypeListColumnBase0, principalDerived.FindProperty("RefTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)valueTypeArrayColumnBase0, principalDerived.FindProperty("ValueTypeArray")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)valueTypeEnumerableColumnBase0, principalDerived.FindProperty("ValueTypeEnumerable")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)valueTypeIListColumnBase0, principalDerived.FindProperty("ValueTypeIList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + RelationalModel.CreateColumnMapping((ColumnBase)valueTypeListColumnBase0, principalDerived.FindProperty("ValueTypeList")!, microsoftEntityFrameworkCoreScaffoldingCompiledModelTestBasePrincipalDerivedMicrosoftEntityFrameworkCoreScaffoldingCompiledModelTestBaseDependentBasebyteMappingBase); + + var tableMappings1 = new List(); + principalDerived.SetRuntimeAnnotation("Relational:TableMappings", tableMappings1); + var principalDerivedTable = new Table("PrincipalDerived", "TPC", relationalModel); + var idColumn1 = new Column("Id", "bigint", principalDerivedTable); + principalDerivedTable.Columns.Add("Id", idColumn1); + idColumn1.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn1); + var enum1Column0 = new Column("Enum1", "int", principalDerivedTable); + principalDerivedTable.Columns.Add("Enum1", enum1Column0); + enum1Column0.Accessors = ColumnAccessorsFactory.CreateGeneric(enum1Column0); + var enum2Column0 = new Column("Enum2", "int", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("Enum2", enum2Column0); + enum2Column0.Accessors = ColumnAccessorsFactory.CreateGeneric(enum2Column0); + var flagsEnum1Column0 = new Column("FlagsEnum1", "int", principalDerivedTable); + principalDerivedTable.Columns.Add("FlagsEnum1", flagsEnum1Column0); + flagsEnum1Column0.Accessors = ColumnAccessorsFactory.CreateGeneric(flagsEnum1Column0); + var flagsEnum2Column0 = new Column("FlagsEnum2", "int", principalDerivedTable); + principalDerivedTable.Columns.Add("FlagsEnum2", flagsEnum2Column0); + flagsEnum2Column0.Accessors = ColumnAccessorsFactory.CreateGeneric(flagsEnum2Column0); + var principalBaseIdColumn0 = new Column("PrincipalBaseId", "bigint", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("PrincipalBaseId", principalBaseIdColumn0); + principalBaseIdColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(principalBaseIdColumn0); + var principalDerivedDependentBasebyteIdColumn0 = new Column("PrincipalDerived>Id", "bigint", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("PrincipalDerived>Id", principalDerivedDependentBasebyteIdColumn0); + principalDerivedDependentBasebyteIdColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(principalDerivedDependentBasebyteIdColumn0); + var refTypeArrayColumn0 = new Column("RefTypeArray", "longtext", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("RefTypeArray", refTypeArrayColumn0); + refTypeArrayColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeArrayColumn0); + var refTypeEnumerableColumn0 = new Column("RefTypeEnumerable", "longtext", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("RefTypeEnumerable", refTypeEnumerableColumn0); + refTypeEnumerableColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeEnumerableColumn0); + var refTypeIListColumn0 = new Column("RefTypeIList", "longtext", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("RefTypeIList", refTypeIListColumn0); + refTypeIListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeIListColumn0); + var refTypeListColumn0 = new Column("RefTypeList", "longtext", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("RefTypeList", refTypeListColumn0); + refTypeListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(refTypeListColumn0); + var valueTypeArrayColumn0 = new Column("ValueTypeArray", "longtext", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("ValueTypeArray", valueTypeArrayColumn0); + valueTypeArrayColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeArrayColumn0); + var valueTypeEnumerableColumn0 = new Column("ValueTypeEnumerable", "longtext", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableColumn0); + valueTypeEnumerableColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeEnumerableColumn0); + var valueTypeIListColumn0 = new Column("ValueTypeIList", "longtext", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("ValueTypeIList", valueTypeIListColumn0); + valueTypeIListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeIListColumn0); + var valueTypeListColumn0 = new Column("ValueTypeList", "longtext", principalDerivedTable) + { + IsNullable = true + }; + principalDerivedTable.Columns.Add("ValueTypeList", valueTypeListColumn0); + valueTypeListColumn0.Accessors = ColumnAccessorsFactory.CreateGeneric(valueTypeListColumn0); + relationalModel.Tables.Add(("PrincipalDerived", "TPC"), principalDerivedTable); + var principalDerivedTableMapping = new TableMapping(principalDerived, principalDerivedTable, null); + principalDerivedTable.AddTypeMapping(principalDerivedTableMapping, false); + tableMappings1.Add(principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(idColumn1, principalDerived.FindProperty("Id")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(enum1Column0, principalDerived.FindProperty("Enum1")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(enum2Column0, principalDerived.FindProperty("Enum2")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(flagsEnum1Column0, principalDerived.FindProperty("FlagsEnum1")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(flagsEnum2Column0, principalDerived.FindProperty("FlagsEnum2")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(principalBaseIdColumn0, principalDerived.FindProperty("PrincipalBaseId")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(principalDerivedDependentBasebyteIdColumn0, principalDerived.FindProperty("PrincipalDerivedId")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(refTypeArrayColumn0, principalDerived.FindProperty("RefTypeArray")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(refTypeEnumerableColumn0, principalDerived.FindProperty("RefTypeEnumerable")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(refTypeIListColumn0, principalDerived.FindProperty("RefTypeIList")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(refTypeListColumn0, principalDerived.FindProperty("RefTypeList")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(valueTypeArrayColumn0, principalDerived.FindProperty("ValueTypeArray")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(valueTypeEnumerableColumn0, principalDerived.FindProperty("ValueTypeEnumerable")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(valueTypeIListColumn0, principalDerived.FindProperty("ValueTypeIList")!, principalDerivedTableMapping); + RelationalModel.CreateColumnMapping(valueTypeListColumn0, principalDerived.FindProperty("ValueTypeList")!, principalDerivedTableMapping); + var pK_PrincipalDerived = new UniqueConstraint("PK_PrincipalDerived", principalDerivedTable, new[] { idColumn1 }); + principalDerivedTable.PrimaryKey = pK_PrincipalDerived; + pK_PrincipalDerived.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(pK_PrincipalDerived)); + pK_PrincipalDerived.MappedKeys.Add(pK_PrincipalBaseKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_PrincipalBaseKey).Add(pK_PrincipalDerived); + principalDerivedTable.UniqueConstraints.Add("PK_PrincipalDerived", pK_PrincipalDerived); + var iX_PrincipalDerived_PrincipalDerivedDependentBasebyteId = new TableIndex( + "IX_PrincipalDerived_PrincipalDerived>Id", principalDerivedTable, new[] { principalDerivedDependentBasebyteIdColumn0 }, false); + iX_PrincipalDerived_PrincipalDerivedDependentBasebyteId.SetRowIndexValueFactory(new SimpleRowIndexValueFactory(iX_PrincipalDerived_PrincipalDerivedDependentBasebyteId)); + iX_PrincipalDerived_PrincipalDerivedDependentBasebyteId.MappedIndexes.Add(iX_PrincipalBase_PrincipalDerivedDependentBasebyteIdIx); + RelationalModel.GetOrCreateTableIndexes(iX_PrincipalBase_PrincipalDerivedDependentBasebyteIdIx).Add(iX_PrincipalDerived_PrincipalDerivedDependentBasebyteId); + principalDerivedTable.Indexes.Add("IX_PrincipalDerived_PrincipalDerived>Id", iX_PrincipalDerived_PrincipalDerivedDependentBasebyteId); + var pIX0 = new TableIndex( + "PIX", principalDerivedTable, new[] { principalBaseIdColumn0 }, true); + pIX0.SetRowIndexValueFactory(new SimpleRowIndexValueFactory(pIX0)); + pIX0.MappedIndexes.Add(pIXIx); + RelationalModel.GetOrCreateTableIndexes(pIXIx).Add(pIX0); + principalDerivedTable.Indexes.Add("PIX", pIX0); + + var viewMappings0 = new List(); + principalDerived.SetRuntimeAnnotation("Relational:ViewMappings", viewMappings0); + var principalDerivedViewView = new View("PrincipalDerivedView", "TPC", relationalModel); + var enum1ViewColumn0 = new ViewColumn("Enum1", "int", principalDerivedViewView); + principalDerivedViewView.Columns.Add("Enum1", enum1ViewColumn0); + var enum2ViewColumn0 = new ViewColumn("Enum2", "int", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("Enum2", enum2ViewColumn0); + var flagsEnum1ViewColumn0 = new ViewColumn("FlagsEnum1", "int", principalDerivedViewView); + principalDerivedViewView.Columns.Add("FlagsEnum1", flagsEnum1ViewColumn0); + var flagsEnum2ViewColumn0 = new ViewColumn("FlagsEnum2", "int", principalDerivedViewView); + principalDerivedViewView.Columns.Add("FlagsEnum2", flagsEnum2ViewColumn0); + var idViewColumn0 = new ViewColumn("Id", "bigint", principalDerivedViewView); + principalDerivedViewView.Columns.Add("Id", idViewColumn0); + var principalBaseIdViewColumn0 = new ViewColumn("PrincipalBaseId", "bigint", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("PrincipalBaseId", principalBaseIdViewColumn0); + var principalDerivedIdViewColumn0 = new ViewColumn("PrincipalDerivedId", "bigint", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("PrincipalDerivedId", principalDerivedIdViewColumn0); + var refTypeArrayViewColumn0 = new ViewColumn("RefTypeArray", "longtext", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("RefTypeArray", refTypeArrayViewColumn0); + var refTypeEnumerableViewColumn0 = new ViewColumn("RefTypeEnumerable", "longtext", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("RefTypeEnumerable", refTypeEnumerableViewColumn0); + var refTypeIListViewColumn0 = new ViewColumn("RefTypeIList", "longtext", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("RefTypeIList", refTypeIListViewColumn0); + var refTypeListViewColumn0 = new ViewColumn("RefTypeList", "longtext", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("RefTypeList", refTypeListViewColumn0); + var valueTypeArrayViewColumn0 = new ViewColumn("ValueTypeArray", "longtext", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("ValueTypeArray", valueTypeArrayViewColumn0); + var valueTypeEnumerableViewColumn0 = new ViewColumn("ValueTypeEnumerable", "longtext", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("ValueTypeEnumerable", valueTypeEnumerableViewColumn0); + var valueTypeIListViewColumn0 = new ViewColumn("ValueTypeIList", "longtext", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("ValueTypeIList", valueTypeIListViewColumn0); + var valueTypeListViewColumn0 = new ViewColumn("ValueTypeList", "longtext", principalDerivedViewView) + { + IsNullable = true + }; + principalDerivedViewView.Columns.Add("ValueTypeList", valueTypeListViewColumn0); + relationalModel.Views.Add(("PrincipalDerivedView", "TPC"), principalDerivedViewView); + var principalDerivedViewViewMapping = new ViewMapping(principalDerived, principalDerivedViewView, null); + principalDerivedViewView.AddTypeMapping(principalDerivedViewViewMapping, false); + viewMappings0.Add(principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(idViewColumn0, principalDerived.FindProperty("Id")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(enum1ViewColumn0, principalDerived.FindProperty("Enum1")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(enum2ViewColumn0, principalDerived.FindProperty("Enum2")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(flagsEnum1ViewColumn0, principalDerived.FindProperty("FlagsEnum1")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(flagsEnum2ViewColumn0, principalDerived.FindProperty("FlagsEnum2")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(principalBaseIdViewColumn0, principalDerived.FindProperty("PrincipalBaseId")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(principalDerivedIdViewColumn0, principalDerived.FindProperty("PrincipalDerivedId")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(refTypeArrayViewColumn0, principalDerived.FindProperty("RefTypeArray")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(refTypeEnumerableViewColumn0, principalDerived.FindProperty("RefTypeEnumerable")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(refTypeIListViewColumn0, principalDerived.FindProperty("RefTypeIList")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(refTypeListViewColumn0, principalDerived.FindProperty("RefTypeList")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(valueTypeArrayViewColumn0, principalDerived.FindProperty("ValueTypeArray")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(valueTypeEnumerableViewColumn0, principalDerived.FindProperty("ValueTypeEnumerable")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(valueTypeIListViewColumn0, principalDerived.FindProperty("ValueTypeIList")!, principalDerivedViewViewMapping); + RelationalModel.CreateViewColumnMapping(valueTypeListViewColumn0, principalDerived.FindProperty("ValueTypeList")!, principalDerivedViewViewMapping); + + var deleteSprocMappings0 = new List(); + principalDerived.SetRuntimeAnnotation("Relational:DeleteStoredProcedureMappings", deleteSprocMappings0); + var derived_DeleteStoreSproc = new StoreStoredProcedure("Derived_Delete", "TPC", relationalModel); + var id_OriginalParameter1 = new StoreStoredProcedureParameter("Id_Original", "bigint", 0, derived_DeleteStoreSproc, System.Data.ParameterDirection.Input); + derived_DeleteStoreSproc.AddParameter(id_OriginalParameter1); + derived_DeleteStoreSproc.AddStoredProcedure((IRuntimeStoredProcedure)principalDerived.GetDeleteStoredProcedure()!); + relationalModel.StoredProcedures.Add(("Derived_Delete", "TPC"), derived_DeleteStoreSproc); + var derived_DeleteDSproc = (IRuntimeStoredProcedure)principalDerived.GetDeleteStoredProcedure()!; + var derived_DeleteSprocMapping = new StoredProcedureMapping(principalDerived, derived_DeleteStoreSproc, derived_DeleteDSproc, principalDerivedTableMapping, null); + derived_DeleteStoreSproc.AddTypeMapping(derived_DeleteSprocMapping, false); + deleteSprocMappings0.Add(derived_DeleteSprocMapping); + principalDerivedTableMapping.DeleteStoredProcedureMapping = derived_DeleteSprocMapping; + RelationalModel.CreateStoredProcedureParameterMapping(id_OriginalParameter1, derived_DeleteDSproc.FindParameter("Id_Original")!, principalDerived.FindProperty("Id")!, derived_DeleteSprocMapping); + + var insertSprocMappings0 = new List(); + principalDerived.SetRuntimeAnnotation("Relational:InsertStoredProcedureMappings", insertSprocMappings0); + var derived_InsertStoreSproc = new StoreStoredProcedure("Derived_Insert", "TPC", relationalModel); + var idParameter0 = new StoreStoredProcedureParameter("Id", "bigint", 0, derived_InsertStoreSproc, System.Data.ParameterDirection.Input); + derived_InsertStoreSproc.AddParameter(idParameter0); + var principalBaseIdParameter1 = new StoreStoredProcedureParameter("PrincipalBaseId", "bigint", 1, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(principalBaseIdParameter1); + var principalDerivedIdParameter1 = new StoreStoredProcedureParameter("PrincipalDerivedId", "bigint", 2, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(principalDerivedIdParameter1); + var enum2Parameter1 = new StoreStoredProcedureParameter("Enum2", "int", 3, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(enum2Parameter1); + var flagsEnum1Parameter1 = new StoreStoredProcedureParameter("FlagsEnum1", "int", 4, derived_InsertStoreSproc, System.Data.ParameterDirection.Input); + derived_InsertStoreSproc.AddParameter(flagsEnum1Parameter1); + var flagsEnum2Parameter1 = new StoreStoredProcedureParameter("FlagsEnum2", "int", 5, derived_InsertStoreSproc, System.Data.ParameterDirection.Input); + derived_InsertStoreSproc.AddParameter(flagsEnum2Parameter1); + var valueTypeListParameter1 = new StoreStoredProcedureParameter("ValueTypeList", "longtext", 6, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(valueTypeListParameter1); + var valueTypeIListParameter1 = new StoreStoredProcedureParameter("ValueTypeIList", "longtext", 7, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(valueTypeIListParameter1); + var valueTypeArrayParameter1 = new StoreStoredProcedureParameter("ValueTypeArray", "longtext", 8, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(valueTypeArrayParameter1); + var valueTypeEnumerableParameter1 = new StoreStoredProcedureParameter("ValueTypeEnumerable", "longtext", 9, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(valueTypeEnumerableParameter1); + var refTypeListParameter1 = new StoreStoredProcedureParameter("RefTypeList", "longtext", 10, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(refTypeListParameter1); + var refTypeIListParameter1 = new StoreStoredProcedureParameter("RefTypeIList", "longtext", 11, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(refTypeIListParameter1); + var refTypeArrayParameter1 = new StoreStoredProcedureParameter("RefTypeArray", "longtext", 12, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(refTypeArrayParameter1); + var refTypeEnumerableParameter1 = new StoreStoredProcedureParameter("RefTypeEnumerable", "longtext", 13, derived_InsertStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_InsertStoreSproc.AddParameter(refTypeEnumerableParameter1); + var derivedEnumFunctionColumn = new StoreStoredProcedureResultColumn("DerivedEnum", "int", 0, derived_InsertStoreSproc); + derived_InsertStoreSproc.AddResultColumn(derivedEnumFunctionColumn); + derived_InsertStoreSproc.AddStoredProcedure((IRuntimeStoredProcedure)principalDerived.GetInsertStoredProcedure()!); + relationalModel.StoredProcedures.Add(("Derived_Insert", "TPC"), derived_InsertStoreSproc); + var derived_InsertISproc = (IRuntimeStoredProcedure)principalDerived.GetInsertStoredProcedure()!; + var derived_InsertSprocMapping = new StoredProcedureMapping(principalDerived, derived_InsertStoreSproc, derived_InsertISproc, principalDerivedTableMapping, null); + derived_InsertStoreSproc.AddTypeMapping(derived_InsertSprocMapping, false); + insertSprocMappings0.Add(derived_InsertSprocMapping); + principalDerivedTableMapping.InsertStoredProcedureMapping = derived_InsertSprocMapping; + RelationalModel.CreateStoredProcedureParameterMapping(idParameter0, derived_InsertISproc.FindParameter("Id")!, principalDerived.FindProperty("Id")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(enum2Parameter1, derived_InsertISproc.FindParameter("Enum2")!, principalDerived.FindProperty("Enum2")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(flagsEnum1Parameter1, derived_InsertISproc.FindParameter("FlagsEnum1")!, principalDerived.FindProperty("FlagsEnum1")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(flagsEnum2Parameter1, derived_InsertISproc.FindParameter("FlagsEnum2")!, principalDerived.FindProperty("FlagsEnum2")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(principalBaseIdParameter1, derived_InsertISproc.FindParameter("PrincipalBaseId")!, principalDerived.FindProperty("PrincipalBaseId")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(principalDerivedIdParameter1, derived_InsertISproc.FindParameter("PrincipalDerivedId")!, principalDerived.FindProperty("PrincipalDerivedId")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeArrayParameter1, derived_InsertISproc.FindParameter("RefTypeArray")!, principalDerived.FindProperty("RefTypeArray")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeEnumerableParameter1, derived_InsertISproc.FindParameter("RefTypeEnumerable")!, principalDerived.FindProperty("RefTypeEnumerable")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeIListParameter1, derived_InsertISproc.FindParameter("RefTypeIList")!, principalDerived.FindProperty("RefTypeIList")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeListParameter1, derived_InsertISproc.FindParameter("RefTypeList")!, principalDerived.FindProperty("RefTypeList")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeArrayParameter1, derived_InsertISproc.FindParameter("ValueTypeArray")!, principalDerived.FindProperty("ValueTypeArray")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeEnumerableParameter1, derived_InsertISproc.FindParameter("ValueTypeEnumerable")!, principalDerived.FindProperty("ValueTypeEnumerable")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeIListParameter1, derived_InsertISproc.FindParameter("ValueTypeIList")!, principalDerived.FindProperty("ValueTypeIList")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeListParameter1, derived_InsertISproc.FindParameter("ValueTypeList")!, principalDerived.FindProperty("ValueTypeList")!, derived_InsertSprocMapping); + RelationalModel.CreateStoredProcedureResultColumnMapping(derivedEnumFunctionColumn, derived_InsertISproc.FindResultColumn("DerivedEnum")!, principalDerived.FindProperty("Enum1")!, derived_InsertSprocMapping); + + var updateSprocMappings0 = new List(); + principalDerived.SetRuntimeAnnotation("Relational:UpdateStoredProcedureMappings", updateSprocMappings0); + var derived_UpdateStoreSproc = new StoreStoredProcedure("Derived_Update", "Derived", relationalModel); + var principalBaseIdParameter2 = new StoreStoredProcedureParameter("PrincipalBaseId", "bigint", 0, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(principalBaseIdParameter2); + var principalDerivedIdParameter2 = new StoreStoredProcedureParameter("PrincipalDerivedId", "bigint", 1, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(principalDerivedIdParameter2); + var enum1Parameter0 = new StoreStoredProcedureParameter("Enum1", "int", 2, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input); + derived_UpdateStoreSproc.AddParameter(enum1Parameter0); + var enum2Parameter2 = new StoreStoredProcedureParameter("Enum2", "int", 3, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(enum2Parameter2); + var flagsEnum1Parameter2 = new StoreStoredProcedureParameter("FlagsEnum1", "int", 4, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input); + derived_UpdateStoreSproc.AddParameter(flagsEnum1Parameter2); + var flagsEnum2Parameter2 = new StoreStoredProcedureParameter("FlagsEnum2", "int", 5, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input); + derived_UpdateStoreSproc.AddParameter(flagsEnum2Parameter2); + var valueTypeListParameter2 = new StoreStoredProcedureParameter("ValueTypeList", "longtext", 6, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(valueTypeListParameter2); + var valueTypeIListParameter2 = new StoreStoredProcedureParameter("ValueTypeIList", "longtext", 7, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(valueTypeIListParameter2); + var valueTypeArrayParameter2 = new StoreStoredProcedureParameter("ValueTypeArray", "longtext", 8, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(valueTypeArrayParameter2); + var valueTypeEnumerableParameter2 = new StoreStoredProcedureParameter("ValueTypeEnumerable", "longtext", 9, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(valueTypeEnumerableParameter2); + var refTypeListParameter2 = new StoreStoredProcedureParameter("RefTypeList", "longtext", 10, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(refTypeListParameter2); + var refTypeIListParameter2 = new StoreStoredProcedureParameter("RefTypeIList", "longtext", 11, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(refTypeIListParameter2); + var refTypeArrayParameter2 = new StoreStoredProcedureParameter("RefTypeArray", "longtext", 12, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(refTypeArrayParameter2); + var refTypeEnumerableParameter2 = new StoreStoredProcedureParameter("RefTypeEnumerable", "longtext", 13, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input) + { + IsNullable = true + }; + derived_UpdateStoreSproc.AddParameter(refTypeEnumerableParameter2); + var id_OriginalParameter2 = new StoreStoredProcedureParameter("Id_Original", "bigint", 14, derived_UpdateStoreSproc, System.Data.ParameterDirection.Input); + derived_UpdateStoreSproc.AddParameter(id_OriginalParameter2); + derived_UpdateStoreSproc.AddStoredProcedure((IRuntimeStoredProcedure)principalDerived.GetUpdateStoredProcedure()!); + relationalModel.StoredProcedures.Add(("Derived_Update", "Derived"), derived_UpdateStoreSproc); + var derived_UpdateUSproc = (IRuntimeStoredProcedure)principalDerived.GetUpdateStoredProcedure()!; + var derived_UpdateSprocMapping = new StoredProcedureMapping(principalDerived, derived_UpdateStoreSproc, derived_UpdateUSproc, principalDerivedTableMapping, null); + derived_UpdateStoreSproc.AddTypeMapping(derived_UpdateSprocMapping, false); + updateSprocMappings0.Add(derived_UpdateSprocMapping); + principalDerivedTableMapping.UpdateStoredProcedureMapping = derived_UpdateSprocMapping; + RelationalModel.CreateStoredProcedureParameterMapping(id_OriginalParameter2, derived_UpdateUSproc.FindParameter("Id_Original")!, principalDerived.FindProperty("Id")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(enum1Parameter0, derived_UpdateUSproc.FindParameter("Enum1")!, principalDerived.FindProperty("Enum1")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(enum2Parameter2, derived_UpdateUSproc.FindParameter("Enum2")!, principalDerived.FindProperty("Enum2")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(flagsEnum1Parameter2, derived_UpdateUSproc.FindParameter("FlagsEnum1")!, principalDerived.FindProperty("FlagsEnum1")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(flagsEnum2Parameter2, derived_UpdateUSproc.FindParameter("FlagsEnum2")!, principalDerived.FindProperty("FlagsEnum2")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(principalBaseIdParameter2, derived_UpdateUSproc.FindParameter("PrincipalBaseId")!, principalDerived.FindProperty("PrincipalBaseId")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(principalDerivedIdParameter2, derived_UpdateUSproc.FindParameter("PrincipalDerivedId")!, principalDerived.FindProperty("PrincipalDerivedId")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeArrayParameter2, derived_UpdateUSproc.FindParameter("RefTypeArray")!, principalDerived.FindProperty("RefTypeArray")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeEnumerableParameter2, derived_UpdateUSproc.FindParameter("RefTypeEnumerable")!, principalDerived.FindProperty("RefTypeEnumerable")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeIListParameter2, derived_UpdateUSproc.FindParameter("RefTypeIList")!, principalDerived.FindProperty("RefTypeIList")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(refTypeListParameter2, derived_UpdateUSproc.FindParameter("RefTypeList")!, principalDerived.FindProperty("RefTypeList")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeArrayParameter2, derived_UpdateUSproc.FindParameter("ValueTypeArray")!, principalDerived.FindProperty("ValueTypeArray")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeEnumerableParameter2, derived_UpdateUSproc.FindParameter("ValueTypeEnumerable")!, principalDerived.FindProperty("ValueTypeEnumerable")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeIListParameter2, derived_UpdateUSproc.FindParameter("ValueTypeIList")!, principalDerived.FindProperty("ValueTypeIList")!, derived_UpdateSprocMapping); + RelationalModel.CreateStoredProcedureParameterMapping(valueTypeListParameter2, derived_UpdateUSproc.FindParameter("ValueTypeList")!, principalDerived.FindProperty("ValueTypeList")!, derived_UpdateSprocMapping); + var fK_DependentBasebyte_PrincipalDerived_PrincipalId = new ForeignKeyConstraint( + "FK_DependentBase_PrincipalDerived_PrincipalId", dependentBasebyteTable, principalDerivedTable, + new[] { principalIdColumn }, + principalDerivedTable.FindUniqueConstraint("PK_PrincipalDerived")!, ReferentialAction.NoAction); + fK_DependentBasebyte_PrincipalDerived_PrincipalId.SetRowForeignKeyValueFactory(RowForeignKeyValueFactoryFactory.CreateSimpleNonNullableFactory(fK_DependentBasebyte_PrincipalDerived_PrincipalId)); + var fK_DependentBasebyte_PrincipalDerived_PrincipalIdFk = RelationalModel.GetForeignKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", + new[] { "PrincipalId" }, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>", + new[] { "Id" }); + fK_DependentBasebyte_PrincipalDerived_PrincipalId.MappedForeignKeys.Add(fK_DependentBasebyte_PrincipalDerived_PrincipalIdFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_DependentBasebyte_PrincipalDerived_PrincipalIdFk).Add(fK_DependentBasebyte_PrincipalDerived_PrincipalId); + dependentBasebyteTable.ForeignKeyConstraints.Add(fK_DependentBasebyte_PrincipalDerived_PrincipalId); + principalDerivedTable.ReferencingForeignKeyConstraints.Add(fK_DependentBasebyte_PrincipalDerived_PrincipalId); + var fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBas = new ForeignKeyConstraint( + "FK_PrincipalBase_PrincipalDerived_PrincipalDerived(fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBas)); + var fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBasFk = RelationalModel.GetForeignKey(this, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", + new[] { "PrincipalDerivedId" }, + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>", + new[] { "Id" }); + fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBas.MappedForeignKeys.Add(fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBasFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBasFk).Add(fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBas); + principalBaseTable.ForeignKeyConstraints.Add(fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBas); + principalDerivedTable.ReferencingForeignKeyConstraints.Add(fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBas); + var fK_PrincipalDerived_PrincipalDerived_PrincipalDerivedDependent = new ForeignKeyConstraint( + "FK_PrincipalDerived_PrincipalDerived_PrincipalDerived(fK_PrincipalDerived_PrincipalDerived_PrincipalDerivedDependent)); + fK_PrincipalDerived_PrincipalDerived_PrincipalDerivedDependent.MappedForeignKeys.Add(fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBasFk); + RelationalModel.GetOrCreateForeignKeyConstraints(fK_PrincipalBase_PrincipalDerived_PrincipalDerivedDependentBasFk).Add(fK_PrincipalDerived_PrincipalDerived_PrincipalDerivedDependent); + principalDerivedTable.ForeignKeyConstraints.Add(fK_PrincipalDerived_PrincipalDerived_PrincipalDerivedDependent); + principalDerivedTable.ReferencingForeignKeyConstraints.Add(fK_PrincipalDerived_PrincipalDerived_PrincipalDerivedDependent); + return relationalModel.MakeReadOnly(); + } + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DependentBaseEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DependentBaseEntityType.cs new file mode 100644 index 000000000..f7d5c6c02 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DependentBaseEntityType.cs @@ -0,0 +1,241 @@ +// +using System; +using System.Collections.Generic; +using System.Reflection; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; +using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage; +using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class DependentBaseEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+DependentBase", + typeof(CompiledModelTestBase.DependentBase), + baseEntityType, + propertyCount: 2, + navigationCount: 1, + foreignKeyCount: 1, + unnamedIndexCount: 1, + keyCount: 1); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(byte?), + propertyInfo: typeof(CompiledModelTestBase.DependentBase).GetProperty("Id", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.DependentBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + afterSaveBehavior: PropertySaveBehavior.Throw); + id.SetGetter( + byte? (CompiledModelTestBase.DependentBase entity) => DependentBaseUnsafeAccessors.Id(entity), + bool (CompiledModelTestBase.DependentBase entity) => !(DependentBaseUnsafeAccessors.Id(entity).HasValue), + byte? (CompiledModelTestBase.DependentBase instance) => DependentBaseUnsafeAccessors.Id(instance), + bool (CompiledModelTestBase.DependentBase instance) => !(DependentBaseUnsafeAccessors.Id(instance).HasValue)); + id.SetSetter( + (CompiledModelTestBase.DependentBase entity, byte? value) => DependentBaseUnsafeAccessors.Id(entity) = value); + id.SetMaterializationSetter( + (CompiledModelTestBase.DependentBase entity, byte? value) => DependentBaseUnsafeAccessors.Id(entity) = value); + id.SetAccessors( + byte? (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Id(((CompiledModelTestBase.DependentBase)(entry.Entity))), + byte? (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Id(((CompiledModelTestBase.DependentBase)(entry.Entity))), + byte? (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 0), + byte? (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + id.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: -1, + relationshipIndex: 0, + storeGenerationIndex: -1); + id.TypeMapping = MySqlByteTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + keyComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + providerValueComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)); + id.SetCurrentValueComparer(new EntryCurrentValueComparer(id)); + id.SetComparer(new NullableValueComparer(id.TypeMapping.Comparer)); + id.SetKeyComparer(new NullableValueComparer(id.TypeMapping.KeyComparer)); + id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var principalId = runtimeEntityType.AddProperty( + "PrincipalId", + typeof(long?), + nullable: true); + principalId.SetAccessors( + long? (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(1) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(1) && !(entry.ReadShadowValue(0).HasValue) ? entry.ReadTemporaryValue(0) : entry.ReadShadowValue(0))), + long? (InternalEntityEntry entry) => entry.ReadShadowValue(0), + long? (InternalEntityEntry entry) => entry.ReadOriginalValue(principalId, 1), + long? (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalId, 1), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + principalId.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: 0, + relationshipIndex: 1, + storeGenerationIndex: 0); + principalId.TypeMapping = MySqlLongTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + keyComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + providerValueComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + principalId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalId)); + principalId.SetComparer(new NullableValueComparer(principalId.TypeMapping.Comparer)); + principalId.SetKeyComparer(new NullableValueComparer(principalId.TypeMapping.KeyComparer)); + principalId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { principalId }, + unique: true); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PrincipalId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType, + deleteBehavior: DeleteBehavior.ClientCascade, + unique: true, + requiredDependent: true); + + var principal = declaringEntityType.AddNavigation("Principal", + runtimeForeignKey, + onDependent: true, + typeof(CompiledModelTestBase.PrincipalDerived>), + propertyInfo: typeof(CompiledModelTestBase.DependentBase).GetProperty("Principal", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.DependentBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + principal.SetGetter( + CompiledModelTestBase.PrincipalDerived> (CompiledModelTestBase.DependentBase entity) => DependentBaseUnsafeAccessors.Principal(entity), + bool (CompiledModelTestBase.DependentBase entity) => DependentBaseUnsafeAccessors.Principal(entity) == null, + CompiledModelTestBase.PrincipalDerived> (CompiledModelTestBase.DependentBase instance) => DependentBaseUnsafeAccessors.Principal(instance), + bool (CompiledModelTestBase.DependentBase instance) => DependentBaseUnsafeAccessors.Principal(instance) == null); + principal.SetSetter( + (CompiledModelTestBase.DependentBase entity, CompiledModelTestBase.PrincipalDerived> value) => DependentBaseUnsafeAccessors.Principal(entity) = value); + principal.SetMaterializationSetter( + (CompiledModelTestBase.DependentBase entity, CompiledModelTestBase.PrincipalDerived> value) => DependentBaseUnsafeAccessors.Principal(entity) = value); + principal.SetAccessors( + CompiledModelTestBase.PrincipalDerived> (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Principal(((CompiledModelTestBase.DependentBase)(entry.Entity))), + CompiledModelTestBase.PrincipalDerived> (InternalEntityEntry entry) => DependentBaseUnsafeAccessors.Principal(((CompiledModelTestBase.DependentBase)(entry.Entity))), + null, + CompiledModelTestBase.PrincipalDerived> (InternalEntityEntry entry) => entry.GetCurrentValue>>(principal), + null); + principal.SetPropertyIndexes( + index: 0, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 2, + storeGenerationIndex: -1); + var dependent = principalEntityType.AddNavigation("Dependent", + runtimeForeignKey, + onDependent: false, + typeof(CompiledModelTestBase.DependentBase), + propertyInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetProperty("Dependent", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + dependent.SetGetter( + CompiledModelTestBase.DependentBase (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Dependent(entity), + bool (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Dependent(entity) == null, + CompiledModelTestBase.DependentBase (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.Dependent(instance), + bool (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.Dependent(instance) == null); + dependent.SetSetter( + (CompiledModelTestBase.PrincipalDerived> entity, CompiledModelTestBase.DependentBase value) => PrincipalDerivedUnsafeAccessors>.Dependent(entity) = value); + dependent.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalDerived> entity, CompiledModelTestBase.DependentBase value) => PrincipalDerivedUnsafeAccessors>.Dependent(entity) = value); + dependent.SetAccessors( + CompiledModelTestBase.DependentBase (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.Dependent(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + CompiledModelTestBase.DependentBase (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.Dependent(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + null, + CompiledModelTestBase.DependentBase (InternalEntityEntry entry) => entry.GetCurrentValue>(dependent), + null); + dependent.SetPropertyIndexes( + index: 1, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 4, + storeGenerationIndex: -1); + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + var id = runtimeEntityType.FindProperty("Id"); + var principalId = runtimeEntityType.FindProperty("PrincipalId"); + var key = runtimeEntityType.FindKey(new[] { id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateSimpleNullableFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory(key)); + var principal = runtimeEntityType.FindNavigation("Principal"); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.DependentBase)(source.Entity)); + return ((ISnapshot)(new Snapshot((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id))), (source.GetCurrentValue(principalId) == null ? null : ((ValueComparer)(((IProperty)principalId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalId)))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot((default(long? ) == null ? null : ((ValueComparer)(((IProperty)principalId).GetValueComparer())).Snapshot(default(long? ))))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(long? ))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("PrincipalId") ? ((long? )(source["PrincipalId"])) : null))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(long? ))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.DependentBase)(source.Entity)); + return ((ISnapshot)(new Snapshot((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))), (source.GetCurrentValue(principalId) == null ? null : ((ValueComparer)(((IProperty)principalId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalId))), DependentBaseUnsafeAccessors.Principal(entity)))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 2, + navigationCount: 1, + complexPropertyCount: 0, + originalValueCount: 2, + shadowCount: 1, + relationshipCount: 3, + storeGeneratedCount: 1); + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", "TPC"); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "DependentBase"); + runtimeEntityType.AddAnnotation("Relational:ViewName", null); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", null); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DependentBaseUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DependentBaseUnsafeAccessors.cs new file mode 100644 index 000000000..d7a27e947 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/DependentBaseUnsafeAccessors.cs @@ -0,0 +1,18 @@ +// +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DependentBaseUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TKey Id(CompiledModelTestBase.DependentBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.PrincipalDerived> Principal(CompiledModelTestBase.DependentBase @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalBaseEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalBaseEntityType.cs new file mode 100644 index 000000000..bb6358b74 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalBaseEntityType.cs @@ -0,0 +1,1177 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Reflection; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; +using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage; +using Microsoft.EntityFrameworkCore.Storage.Json; +using Microsoft.EntityFrameworkCore.Storage.ValueConversion; +using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class PrincipalBaseEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalBase", + typeof(CompiledModelTestBase.PrincipalBase), + baseEntityType, + discriminatorValue: "PrincipalBase", + derivedTypesCount: 1, + propertyCount: 15, + navigationCount: 1, + foreignKeyCount: 2, + unnamedIndexCount: 1, + namedIndexCount: 1, + keyCount: 1); + + var id = runtimeEntityType.AddProperty( + "Id", + typeof(long?), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Id", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + afterSaveBehavior: PropertySaveBehavior.Throw); + id.SetGetter( + long? (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Id(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => !(PrincipalBaseUnsafeAccessors.Id(entity).HasValue), + long? (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Id(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => !(PrincipalBaseUnsafeAccessors.Id(instance).HasValue)); + id.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, long? value) => PrincipalBaseUnsafeAccessors.Id(entity) = value); + id.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, long? value) => PrincipalBaseUnsafeAccessors.Id(entity) = value); + id.SetAccessors( + long? (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Id(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + long? (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Id(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + long? (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 0), + long? (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + id.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: -1, + relationshipIndex: 0, + storeGenerationIndex: -1); + id.TypeMapping = MySqlLongTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + keyComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + providerValueComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + id.SetCurrentValueComparer(new EntryCurrentValueComparer(id)); + id.SetComparer(new NullableValueComparer(id.TypeMapping.Comparer)); + id.SetKeyComparer(new NullableValueComparer(id.TypeMapping.KeyComparer)); + + var overrides = new StoreObjectDictionary(); + var idPrincipalBaseView = new RuntimeRelationalPropertyOverrides( + id, + StoreObjectIdentifier.View("PrincipalBaseView", "TPC"), + false, + null); + idPrincipalBaseView.AddAnnotation("foo", "bar2"); + overrides.Add(StoreObjectIdentifier.View("PrincipalBaseView", "TPC"), idPrincipalBaseView); + id.AddAnnotation("Relational:RelationalOverrides", overrides); + + id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var enum1 = runtimeEntityType.AddProperty( + "Enum1", + typeof(CompiledModelTestBase.AnEnum), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Enum1", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + valueGenerated: ValueGenerated.OnAdd); + enum1.SetGetter( + CompiledModelTestBase.AnEnum (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Enum1(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.Enum1(entity))), ((object)(CompiledModelTestBase.AnEnum.A))), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Enum1(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.Enum1(instance))), ((object)(CompiledModelTestBase.AnEnum.A)))); + enum1.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AnEnum value) => PrincipalBaseUnsafeAccessors.Enum1(entity) = value); + enum1.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AnEnum value) => PrincipalBaseUnsafeAccessors.Enum1(entity) = value); + enum1.SetAccessors( + CompiledModelTestBase.AnEnum (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(1) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(1) && object.Equals(((object)(PrincipalBaseUnsafeAccessors.Enum1(((CompiledModelTestBase.PrincipalBase)(entry.Entity))))), ((object)(CompiledModelTestBase.AnEnum.A))) ? entry.ReadTemporaryValue(0) : PrincipalBaseUnsafeAccessors.Enum1(((CompiledModelTestBase.PrincipalBase)(entry.Entity))))), + CompiledModelTestBase.AnEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Enum1(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AnEnum (InternalEntityEntry entry) => entry.ReadOriginalValue(enum1, 1), + CompiledModelTestBase.AnEnum (InternalEntityEntry entry) => entry.GetCurrentValue(enum1), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + enum1.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: 0); + enum1.TypeMapping = MySqlIntTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AnEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.AnEnum v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AnEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.AnEnum v) => v), + providerValueComparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), + converter: new ValueConverter( + int (CompiledModelTestBase.AnEnum value) => ((int)(value)), + CompiledModelTestBase.AnEnum (int value) => ((CompiledModelTestBase.AnEnum)(value))), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonInt32ReaderWriter.Instance, + new ValueConverter( + int (CompiledModelTestBase.AnEnum value) => ((int)(value)), + CompiledModelTestBase.AnEnum (int value) => ((CompiledModelTestBase.AnEnum)(value))))); + enum1.SetSentinelFromProviderValue(1); + + var overrides0 = new StoreObjectDictionary(); + var enum1Derived_Insert = new RuntimeRelationalPropertyOverrides( + enum1, + StoreObjectIdentifier.InsertStoredProcedure("Derived_Insert", "TPC"), + true, + "DerivedEnum"); + overrides0.Add(StoreObjectIdentifier.InsertStoredProcedure("Derived_Insert", "TPC"), enum1Derived_Insert); + enum1.AddAnnotation("Relational:RelationalOverrides", overrides0); + + enum1.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + enum1.AddAnnotation("Relational:DefaultValue", CompiledModelTestBase.AnEnum.A); + + var enum2 = runtimeEntityType.AddProperty( + "Enum2", + typeof(CompiledModelTestBase.AnEnum?), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Enum2", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + enum2.SetGetter( + CompiledModelTestBase.AnEnum? (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Enum2(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => !(PrincipalBaseUnsafeAccessors.Enum2(entity).HasValue), + CompiledModelTestBase.AnEnum? (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Enum2(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => !(PrincipalBaseUnsafeAccessors.Enum2(instance).HasValue)); + enum2.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AnEnum? value) => PrincipalBaseUnsafeAccessors.Enum2(entity) = (value == null ? value : ((CompiledModelTestBase.AnEnum? )(((CompiledModelTestBase.AnEnum)(value)))))); + enum2.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AnEnum? value) => PrincipalBaseUnsafeAccessors.Enum2(entity) = (value == null ? value : ((CompiledModelTestBase.AnEnum? )(((CompiledModelTestBase.AnEnum)(value)))))); + enum2.SetAccessors( + CompiledModelTestBase.AnEnum? (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Enum2(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AnEnum? (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Enum2(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AnEnum? (InternalEntityEntry entry) => entry.ReadOriginalValue(enum2, 2), + CompiledModelTestBase.AnEnum? (InternalEntityEntry entry) => entry.GetCurrentValue(enum2), + object (ValueBuffer valueBuffer) => valueBuffer[2]); + enum2.SetPropertyIndexes( + index: 2, + originalValueIndex: 2, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + enum2.TypeMapping = MySqlIntTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AnEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.AnEnum v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.AnEnum v1, CompiledModelTestBase.AnEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AnEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AnEnum (CompiledModelTestBase.AnEnum v) => v), + providerValueComparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), + converter: new ValueConverter( + int (CompiledModelTestBase.AnEnum value) => ((int)(value)), + CompiledModelTestBase.AnEnum (int value) => ((CompiledModelTestBase.AnEnum)(value))), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonInt32ReaderWriter.Instance, + new ValueConverter( + int (CompiledModelTestBase.AnEnum value) => ((int)(value)), + CompiledModelTestBase.AnEnum (int value) => ((CompiledModelTestBase.AnEnum)(value))))); + enum2.SetComparer(new NullableValueComparer(enum2.TypeMapping.Comparer)); + enum2.SetKeyComparer(new NullableValueComparer(enum2.TypeMapping.KeyComparer)); + enum2.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var flagsEnum1 = runtimeEntityType.AddProperty( + "FlagsEnum1", + typeof(CompiledModelTestBase.AFlagsEnum), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("FlagsEnum1", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + flagsEnum1.SetGetter( + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.FlagsEnum1(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.FlagsEnum1(entity))), ((object)((CompiledModelTestBase.AFlagsEnum)0L))), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.FlagsEnum1(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.FlagsEnum1(instance))), ((object)((CompiledModelTestBase.AFlagsEnum)0L)))); + flagsEnum1.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AFlagsEnum value) => PrincipalBaseUnsafeAccessors.FlagsEnum1(entity) = value); + flagsEnum1.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AFlagsEnum value) => PrincipalBaseUnsafeAccessors.FlagsEnum1(entity) = value); + flagsEnum1.SetAccessors( + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.FlagsEnum1(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.FlagsEnum1(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => entry.ReadOriginalValue(flagsEnum1, 3), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => entry.GetCurrentValue(flagsEnum1), + object (ValueBuffer valueBuffer) => valueBuffer[3]); + flagsEnum1.SetPropertyIndexes( + index: 3, + originalValueIndex: 3, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + flagsEnum1.TypeMapping = MySqlIntTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AFlagsEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.AFlagsEnum v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AFlagsEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.AFlagsEnum v) => v), + providerValueComparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), + converter: new ValueConverter( + int (CompiledModelTestBase.AFlagsEnum value) => ((int)(value)), + CompiledModelTestBase.AFlagsEnum (int value) => ((CompiledModelTestBase.AFlagsEnum)(value))), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonInt32ReaderWriter.Instance, + new ValueConverter( + int (CompiledModelTestBase.AFlagsEnum value) => ((int)(value)), + CompiledModelTestBase.AFlagsEnum (int value) => ((CompiledModelTestBase.AFlagsEnum)(value))))); + flagsEnum1.SetSentinelFromProviderValue(0); + flagsEnum1.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var flagsEnum2 = runtimeEntityType.AddProperty( + "FlagsEnum2", + typeof(CompiledModelTestBase.AFlagsEnum), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("FlagsEnum2", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + flagsEnum2.SetGetter( + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.FlagsEnum2(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.FlagsEnum2(entity))), ((object)((CompiledModelTestBase.AFlagsEnum)0L))), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.FlagsEnum2(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => object.Equals(((object)(PrincipalBaseUnsafeAccessors.FlagsEnum2(instance))), ((object)((CompiledModelTestBase.AFlagsEnum)0L)))); + flagsEnum2.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AFlagsEnum value) => PrincipalBaseUnsafeAccessors.FlagsEnum2(entity) = value); + flagsEnum2.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, CompiledModelTestBase.AFlagsEnum value) => PrincipalBaseUnsafeAccessors.FlagsEnum2(entity) = value); + flagsEnum2.SetAccessors( + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.FlagsEnum2(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.FlagsEnum2(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => entry.ReadOriginalValue(flagsEnum2, 4), + CompiledModelTestBase.AFlagsEnum (InternalEntityEntry entry) => entry.GetCurrentValue(flagsEnum2), + object (ValueBuffer valueBuffer) => valueBuffer[4]); + flagsEnum2.SetPropertyIndexes( + index: 4, + originalValueIndex: 4, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + flagsEnum2.TypeMapping = MySqlIntTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AFlagsEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.AFlagsEnum v) => v), + keyComparer: new ValueComparer( + bool (CompiledModelTestBase.AFlagsEnum v1, CompiledModelTestBase.AFlagsEnum v2) => object.Equals(((object)(v1)), ((object)(v2))), + int (CompiledModelTestBase.AFlagsEnum v) => ((object)v).GetHashCode(), + CompiledModelTestBase.AFlagsEnum (CompiledModelTestBase.AFlagsEnum v) => v), + providerValueComparer: new ValueComparer( + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), + converter: new ValueConverter( + int (CompiledModelTestBase.AFlagsEnum value) => ((int)(value)), + CompiledModelTestBase.AFlagsEnum (int value) => ((CompiledModelTestBase.AFlagsEnum)(value))), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonInt32ReaderWriter.Instance, + new ValueConverter( + int (CompiledModelTestBase.AFlagsEnum value) => ((int)(value)), + CompiledModelTestBase.AFlagsEnum (int value) => ((CompiledModelTestBase.AFlagsEnum)(value))))); + flagsEnum2.SetSentinelFromProviderValue(0); + flagsEnum2.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var principalBaseId = runtimeEntityType.AddProperty( + "PrincipalBaseId", + typeof(long?), + nullable: true); + principalBaseId.SetAccessors( + long? (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(5) ? entry.ReadStoreGeneratedValue(1) : (entry.FlaggedAsTemporary(5) && !(entry.ReadShadowValue(0).HasValue) ? entry.ReadTemporaryValue(1) : entry.ReadShadowValue(0))), + long? (InternalEntityEntry entry) => entry.ReadShadowValue(0), + long? (InternalEntityEntry entry) => entry.ReadOriginalValue(principalBaseId, 5), + long? (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalBaseId, 1), + object (ValueBuffer valueBuffer) => valueBuffer[5]); + principalBaseId.SetPropertyIndexes( + index: 5, + originalValueIndex: 5, + shadowIndex: 0, + relationshipIndex: 1, + storeGenerationIndex: 1); + principalBaseId.TypeMapping = MySqlLongTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + keyComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + providerValueComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + principalBaseId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalBaseId)); + principalBaseId.SetComparer(new NullableValueComparer(principalBaseId.TypeMapping.Comparer)); + principalBaseId.SetKeyComparer(new NullableValueComparer(principalBaseId.TypeMapping.KeyComparer)); + principalBaseId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var principalDerivedId = runtimeEntityType.AddProperty( + "PrincipalDerivedId", + typeof(long?), + nullable: true); + principalDerivedId.SetAccessors( + long? (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(6) ? entry.ReadStoreGeneratedValue(2) : (entry.FlaggedAsTemporary(6) && !(entry.ReadShadowValue(1).HasValue) ? entry.ReadTemporaryValue(2) : entry.ReadShadowValue(1))), + long? (InternalEntityEntry entry) => entry.ReadShadowValue(1), + long? (InternalEntityEntry entry) => entry.ReadOriginalValue(principalDerivedId, 6), + long? (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(principalDerivedId, 2), + object (ValueBuffer valueBuffer) => valueBuffer[6]); + principalDerivedId.SetPropertyIndexes( + index: 6, + originalValueIndex: 6, + shadowIndex: 1, + relationshipIndex: 2, + storeGenerationIndex: 2); + principalDerivedId.TypeMapping = MySqlLongTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + keyComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v), + providerValueComparer: new ValueComparer( + bool (long v1, long v2) => v1 == v2, + int (long v) => ((object)v).GetHashCode(), + long (long v) => v)); + principalDerivedId.SetCurrentValueComparer(new EntryCurrentValueComparer(principalDerivedId)); + principalDerivedId.SetComparer(new NullableValueComparer(principalDerivedId.TypeMapping.Comparer)); + principalDerivedId.SetKeyComparer(new NullableValueComparer(principalDerivedId.TypeMapping.KeyComparer)); + principalDerivedId.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeArray = runtimeEntityType.AddProperty( + "RefTypeArray", + typeof(IPAddress[]), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeArray.SetGetter( + IPAddress[] (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeArray(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeArray(entity) == null, + IPAddress[] (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeArray(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeArray(instance) == null); + refTypeArray.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IPAddress[] value) => PrincipalBaseUnsafeAccessors.RefTypeArray(entity) = value); + refTypeArray.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IPAddress[] value) => PrincipalBaseUnsafeAccessors.RefTypeArray(entity) = value); + refTypeArray.SetAccessors( + IPAddress[] (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeArray(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeArray(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IPAddress[] (InternalEntityEntry entry) => entry.ReadOriginalValue(refTypeArray, 7), + IPAddress[] (InternalEntityEntry entry) => entry.GetCurrentValue(refTypeArray), + object (ValueBuffer valueBuffer) => valueBuffer[7]); + refTypeArray.SetPropertyIndexes( + index: 7, + originalValueIndex: 7, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + refTypeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter( + new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), + storeTypePostfix: StoreTypePostfix.None, + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter( + new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), + elementMapping: MySqlStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), + keyComparer: new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "varchar(45)", + size: 45), + converter: new ValueConverter( + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); + refTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeEnumerable = runtimeEntityType.AddProperty( + "RefTypeEnumerable", + typeof(IEnumerable), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeEnumerable.SetGetter( + IEnumerable (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(entity) == null, + IEnumerable (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(instance) == null); + refTypeEnumerable.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IEnumerable value) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(entity) = value); + refTypeEnumerable.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IEnumerable value) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(entity) = value); + refTypeEnumerable.SetAccessors( + IEnumerable (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeEnumerable(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeEnumerable, 8), + IEnumerable (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeEnumerable), + object (ValueBuffer valueBuffer) => valueBuffer[8]); + refTypeEnumerable.SetPropertyIndexes( + index: 8, + originalValueIndex: 8, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + refTypeEnumerable.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, string>( + JsonStringReaderWriter.Instance)), + storeTypePostfix: StoreTypePostfix.None, + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, string>( + JsonStringReaderWriter.Instance), + elementMapping: MySqlStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + keyComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + storeTypePostfix: StoreTypePostfix.None)); + refTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeIList = runtimeEntityType.AddProperty( + "RefTypeIList", + typeof(IList), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeIList.SetGetter( + IList (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeIList(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeIList(entity) == null, + IList (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeIList(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeIList(instance) == null); + refTypeIList.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IList value) => PrincipalBaseUnsafeAccessors.RefTypeIList(entity) = value); + refTypeIList.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IList value) => PrincipalBaseUnsafeAccessors.RefTypeIList(entity) = value); + refTypeIList.SetAccessors( + IList (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeIList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IList (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeIList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IList (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeIList, 9), + IList (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeIList), + object (ValueBuffer valueBuffer) => valueBuffer[9]); + refTypeIList.SetPropertyIndexes( + index: 9, + originalValueIndex: 9, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + refTypeIList.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + keyComparer: new ListOfReferenceTypesComparer, string>(new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, string>( + JsonStringReaderWriter.Instance)), + storeTypePostfix: StoreTypePostfix.None, + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, string>( + JsonStringReaderWriter.Instance), + elementMapping: MySqlStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + keyComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + storeTypePostfix: StoreTypePostfix.None)); + refTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var refTypeList = runtimeEntityType.AddProperty( + "RefTypeList", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("RefTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + refTypeList.SetGetter( + List (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeList(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.RefTypeList(entity) == null, + List (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeList(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.RefTypeList(instance) == null); + refTypeList.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, List value) => PrincipalBaseUnsafeAccessors.RefTypeList(entity) = value); + refTypeList.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, List value) => PrincipalBaseUnsafeAccessors.RefTypeList(entity) = value); + refTypeList.SetAccessors( + List (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + List (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.RefTypeList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(refTypeList, 10), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(refTypeList), + object (ValueBuffer valueBuffer) => valueBuffer[10]); + refTypeList.SetPropertyIndexes( + index: 10, + originalValueIndex: 10, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + refTypeList.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ListOfReferenceTypesComparer, IPAddress>(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + keyComparer: new ListOfReferenceTypesComparer, IPAddress>(new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + converter: new CollectionToJsonStringConverter(new JsonCollectionOfReferencesReaderWriter, IPAddress>( + new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))), + storeTypePostfix: StoreTypePostfix.None, + jsonValueReaderWriter: new JsonCollectionOfReferencesReaderWriter, IPAddress>( + new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)))), + elementMapping: MySqlStringTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), + keyComparer: new ValueComparer( + bool (IPAddress v1, IPAddress v2) => v1 == null && v2 == null || v1 != null && v2 != null && v1.Equals(v2), + int (IPAddress v) => ((object)v).GetHashCode(), + IPAddress (IPAddress v) => v), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "varchar(45)", + size: 45), + converter: new ValueConverter( + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v)), + jsonValueReaderWriter: new JsonConvertedValueReaderWriter( + JsonStringReaderWriter.Instance, + new ValueConverter( + string (IPAddress v) => ((object)v).ToString(), + IPAddress (string v) => IPAddress.Parse(v))))); + refTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeArray = runtimeEntityType.AddProperty( + "ValueTypeArray", + typeof(DateTime[]), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeArray", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeArray.SetGetter( + DateTime[] (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeArray(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeArray(entity) == null, + DateTime[] (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeArray(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeArray(instance) == null); + valueTypeArray.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, DateTime[] value) => PrincipalBaseUnsafeAccessors.ValueTypeArray(entity) = value); + valueTypeArray.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, DateTime[] value) => PrincipalBaseUnsafeAccessors.ValueTypeArray(entity) = value); + valueTypeArray.SetAccessors( + DateTime[] (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeArray(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeArray(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + DateTime[] (InternalEntityEntry entry) => entry.ReadOriginalValue(valueTypeArray, 11), + DateTime[] (InternalEntityEntry entry) => entry.GetCurrentValue(valueTypeArray), + object (ValueBuffer valueBuffer) => valueBuffer[11]); + valueTypeArray.SetPropertyIndexes( + index: 11, + originalValueIndex: 11, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + valueTypeArray.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), + keyComparer: new ListOfValueTypesComparer(new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter( + JsonDateTimeReaderWriter.Instance)), + storeTypePostfix: StoreTypePostfix.None, + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter( + JsonDateTimeReaderWriter.Instance), + elementMapping: MySqlDateTimeTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), + keyComparer: new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), + providerValueComparer: new ValueComparer( + bool (DateTime v1, DateTime v2) => v1.Equals(v2), + int (DateTime v) => ((object)v).GetHashCode(), + DateTime (DateTime v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "datetime(6)", + precision: 6))); + valueTypeArray.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeEnumerable = runtimeEntityType.AddProperty( + "ValueTypeEnumerable", + typeof(IEnumerable), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeEnumerable", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeEnumerable.SetGetter( + IEnumerable (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(entity) == null, + IEnumerable (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(instance) == null); + valueTypeEnumerable.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IEnumerable value) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(entity) = value); + valueTypeEnumerable.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IEnumerable value) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(entity) = value); + valueTypeEnumerable.SetAccessors( + IEnumerable (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeEnumerable(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IEnumerable (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeEnumerable, 12), + IEnumerable (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeEnumerable), + object (ValueBuffer valueBuffer) => valueBuffer[12]); + valueTypeEnumerable.SetPropertyIndexes( + index: 12, + originalValueIndex: 12, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + valueTypeEnumerable.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + keyComparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, byte>( + JsonByteReaderWriter.Instance)), + storeTypePostfix: StoreTypePostfix.None, + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, byte>( + JsonByteReaderWriter.Instance), + elementMapping: MySqlByteTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + keyComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + providerValueComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))); + valueTypeEnumerable.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeIList = runtimeEntityType.AddProperty( + "ValueTypeIList", + typeof(IList), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeIList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeIList.SetGetter( + IList (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeIList(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeIList(entity) == null, + IList (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeIList(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeIList(instance) == null); + valueTypeIList.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, IList value) => PrincipalBaseUnsafeAccessors.ValueTypeIList(entity) = value); + valueTypeIList.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, IList value) => PrincipalBaseUnsafeAccessors.ValueTypeIList(entity) = value); + valueTypeIList.SetAccessors( + IList (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeIList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IList (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeIList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + IList (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeIList, 13), + IList (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeIList), + object (ValueBuffer valueBuffer) => valueBuffer[13]); + valueTypeIList.SetPropertyIndexes( + index: 13, + originalValueIndex: 13, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + valueTypeIList.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + keyComparer: new ListOfValueTypesComparer, byte>(new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, byte>( + JsonByteReaderWriter.Instance)), + storeTypePostfix: StoreTypePostfix.None, + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, byte>( + JsonByteReaderWriter.Instance), + elementMapping: MySqlByteTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + keyComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v), + providerValueComparer: new ValueComparer( + bool (byte v1, byte v2) => v1 == v2, + int (byte v) => ((int)(v)), + byte (byte v) => v))); + valueTypeIList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var valueTypeList = runtimeEntityType.AddProperty( + "ValueTypeList", + typeof(List), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("ValueTypeList", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), + nullable: true); + valueTypeList.SetGetter( + List (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeList(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.ValueTypeList(entity) == null, + List (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeList(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.ValueTypeList(instance) == null); + valueTypeList.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, List value) => PrincipalBaseUnsafeAccessors.ValueTypeList(entity) = value); + valueTypeList.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, List value) => PrincipalBaseUnsafeAccessors.ValueTypeList(entity) = value); + valueTypeList.SetAccessors( + List (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + List (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.ValueTypeList(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + List (InternalEntityEntry entry) => entry.ReadOriginalValue>(valueTypeList, 14), + List (InternalEntityEntry entry) => entry.GetCurrentValue>(valueTypeList), + object (ValueBuffer valueBuffer) => valueBuffer[14]); + valueTypeList.SetPropertyIndexes( + index: 14, + originalValueIndex: 14, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); + valueTypeList.TypeMapping = MySqlStringTypeMapping.Default.Clone( + comparer: new ListOfValueTypesComparer, short>(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), + keyComparer: new ListOfValueTypesComparer, short>(new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v)), + providerValueComparer: new ValueComparer( + bool (string v1, string v2) => v1 == v2, + int (string v) => ((object)v).GetHashCode(), + string (string v) => v), + mappingInfo: new RelationalTypeMappingInfo( + storeTypeName: "longtext"), + converter: new CollectionToJsonStringConverter(new JsonCollectionOfStructsReaderWriter, short>( + JsonInt16ReaderWriter.Instance)), + storeTypePostfix: StoreTypePostfix.None, + jsonValueReaderWriter: new JsonCollectionOfStructsReaderWriter, short>( + JsonInt16ReaderWriter.Instance), + elementMapping: MySqlShortTypeMapping.Default.Clone( + comparer: new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), + keyComparer: new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v), + providerValueComparer: new ValueComparer( + bool (short v1, short v2) => v1 == v2, + int (short v) => ((int)(v)), + short (short v) => v))); + valueTypeList.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); + + var key = runtimeEntityType.AddKey( + new[] { id }); + runtimeEntityType.SetPrimaryKey(key); + + var index = runtimeEntityType.AddIndex( + new[] { principalDerivedId }); + + var principalIndex = runtimeEntityType.AddIndex( + new[] { principalBaseId }, + name: "PrincipalIndex", + unique: true); + principalIndex.AddAnnotation("Relational:Filter", "AlternateId <> NULL"); + principalIndex.AddAnnotation("Relational:Name", "PIX"); + + return runtimeEntityType; + } + + public static RuntimeForeignKey CreateForeignKey1(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PrincipalBaseId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType); + + var deriveds = principalEntityType.AddNavigation("Deriveds", + runtimeForeignKey, + onDependent: false, + typeof(ICollection), + propertyInfo: typeof(CompiledModelTestBase.PrincipalBase).GetProperty("Deriveds", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalBase).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + deriveds.SetGetter( + ICollection (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Deriveds(entity), + bool (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Deriveds(entity) == null, + ICollection (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Deriveds(instance), + bool (CompiledModelTestBase.PrincipalBase instance) => PrincipalBaseUnsafeAccessors.Deriveds(instance) == null); + deriveds.SetSetter( + (CompiledModelTestBase.PrincipalBase entity, ICollection value) => PrincipalBaseUnsafeAccessors.Deriveds(entity) = value); + deriveds.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalBase entity, ICollection value) => PrincipalBaseUnsafeAccessors.Deriveds(entity) = value); + deriveds.SetAccessors( + ICollection (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Deriveds(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + ICollection (InternalEntityEntry entry) => PrincipalBaseUnsafeAccessors.Deriveds(((CompiledModelTestBase.PrincipalBase)(entry.Entity))), + null, + ICollection (InternalEntityEntry entry) => entry.GetCurrentValue>(deriveds), + null); + deriveds.SetPropertyIndexes( + index: 0, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 3, + storeGenerationIndex: -1); + deriveds.SetCollectionAccessor, CompiledModelTestBase.PrincipalBase>( + ICollection (CompiledModelTestBase.PrincipalBase entity) => PrincipalBaseUnsafeAccessors.Deriveds(entity), + (CompiledModelTestBase.PrincipalBase entity, ICollection collection) => PrincipalBaseUnsafeAccessors.Deriveds(entity) = ((ICollection)(collection)), + (CompiledModelTestBase.PrincipalBase entity, ICollection collection) => PrincipalBaseUnsafeAccessors.Deriveds(entity) = ((ICollection)(collection)), + ICollection (CompiledModelTestBase.PrincipalBase entity, Action> setter) => ClrCollectionAccessorFactory.CreateAndSetHashSet, CompiledModelTestBase.PrincipalBase>(entity, setter), + ICollection () => ((ICollection)(((ICollection)(new HashSet(ReferenceEqualityComparer.Instance)))))); + return runtimeForeignKey; + } + + public static RuntimeForeignKey CreateForeignKey2(RuntimeEntityType declaringEntityType, RuntimeEntityType principalEntityType) + { + var runtimeForeignKey = declaringEntityType.AddForeignKey(new[] { declaringEntityType.FindProperty("PrincipalDerivedId") }, + principalEntityType.FindKey(new[] { principalEntityType.FindProperty("Id") }), + principalEntityType); + + var principals = principalEntityType.AddNavigation("Principals", + runtimeForeignKey, + onDependent: false, + typeof(ICollection), + propertyInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetProperty("Principals", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), + fieldInfo: typeof(CompiledModelTestBase.PrincipalDerived>).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly)); + + principals.SetGetter( + ICollection (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Principals(entity), + bool (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Principals(entity) == null, + ICollection (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.Principals(instance), + bool (CompiledModelTestBase.PrincipalDerived> instance) => PrincipalDerivedUnsafeAccessors>.Principals(instance) == null); + principals.SetSetter( + (CompiledModelTestBase.PrincipalDerived> entity, ICollection value) => PrincipalDerivedUnsafeAccessors>.Principals(entity) = value); + principals.SetMaterializationSetter( + (CompiledModelTestBase.PrincipalDerived> entity, ICollection value) => PrincipalDerivedUnsafeAccessors>.Principals(entity) = value); + principals.SetAccessors( + ICollection (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.Principals(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + ICollection (InternalEntityEntry entry) => PrincipalDerivedUnsafeAccessors>.Principals(((CompiledModelTestBase.PrincipalDerived>)(entry.Entity))), + null, + ICollection (InternalEntityEntry entry) => entry.GetCurrentValue>(principals), + null); + principals.SetPropertyIndexes( + index: 2, + originalValueIndex: -1, + shadowIndex: -1, + relationshipIndex: 5, + storeGenerationIndex: -1); + principals.SetCollectionAccessor>, ICollection, CompiledModelTestBase.PrincipalBase>( + ICollection (CompiledModelTestBase.PrincipalDerived> entity) => PrincipalDerivedUnsafeAccessors>.Principals(entity), + (CompiledModelTestBase.PrincipalDerived> entity, ICollection collection) => PrincipalDerivedUnsafeAccessors>.Principals(entity) = ((ICollection)(collection)), + (CompiledModelTestBase.PrincipalDerived> entity, ICollection collection) => PrincipalDerivedUnsafeAccessors>.Principals(entity) = ((ICollection)(collection)), + ICollection (CompiledModelTestBase.PrincipalDerived> entity, Action>, ICollection> setter) => ClrCollectionAccessorFactory.CreateAndSetHashSet>, ICollection, CompiledModelTestBase.PrincipalBase>(entity, setter), + ICollection () => ((ICollection)(((ICollection)(new HashSet(ReferenceEqualityComparer.Instance)))))); + return runtimeForeignKey; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + var id = runtimeEntityType.FindProperty("Id"); + var enum1 = runtimeEntityType.FindProperty("Enum1"); + var enum2 = runtimeEntityType.FindProperty("Enum2"); + var flagsEnum1 = runtimeEntityType.FindProperty("FlagsEnum1"); + var flagsEnum2 = runtimeEntityType.FindProperty("FlagsEnum2"); + var principalBaseId = runtimeEntityType.FindProperty("PrincipalBaseId"); + var principalDerivedId = runtimeEntityType.FindProperty("PrincipalDerivedId"); + var refTypeArray = runtimeEntityType.FindProperty("RefTypeArray"); + var refTypeEnumerable = runtimeEntityType.FindProperty("RefTypeEnumerable"); + var refTypeIList = runtimeEntityType.FindProperty("RefTypeIList"); + var refTypeList = runtimeEntityType.FindProperty("RefTypeList"); + var valueTypeArray = runtimeEntityType.FindProperty("ValueTypeArray"); + var valueTypeEnumerable = runtimeEntityType.FindProperty("ValueTypeEnumerable"); + var valueTypeIList = runtimeEntityType.FindProperty("ValueTypeIList"); + var valueTypeList = runtimeEntityType.FindProperty("ValueTypeList"); + var key = runtimeEntityType.FindKey(new[] { id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateSimpleNullableFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory(key)); + var deriveds = runtimeEntityType.FindNavigation("Deriveds"); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.PrincipalBase)(source.Entity)); + return ((ISnapshot)(new Snapshot, IList, List, DateTime[], IEnumerable, IList, List>((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id))), ((ValueComparer)(((IProperty)enum1).GetValueComparer())).Snapshot(source.GetCurrentValue(enum1)), (source.GetCurrentValue(enum2) == null ? null : ((ValueComparer)(((IProperty)enum2).GetValueComparer())).Snapshot(source.GetCurrentValue(enum2))), ((ValueComparer)(((IProperty)flagsEnum1).GetValueComparer())).Snapshot(source.GetCurrentValue(flagsEnum1)), ((ValueComparer)(((IProperty)flagsEnum2).GetValueComparer())).Snapshot(source.GetCurrentValue(flagsEnum2)), (source.GetCurrentValue(principalBaseId) == null ? null : ((ValueComparer)(((IProperty)principalBaseId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalBaseId))), (source.GetCurrentValue(principalDerivedId) == null ? null : ((ValueComparer)(((IProperty)principalDerivedId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalDerivedId))), (((object)(source.GetCurrentValue(refTypeArray))) == null ? null : ((IPAddress[])(((ValueComparer)(((IProperty)refTypeArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(refTypeArray))))))), (((object)(source.GetCurrentValue>(refTypeEnumerable))) == null ? null : ((IEnumerable)(((ValueComparer)(((IProperty)refTypeEnumerable).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeEnumerable))))))), (((object)(source.GetCurrentValue>(refTypeIList))) == null ? null : ((IList)(((ValueComparer)(((IProperty)refTypeIList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeIList))))))), (((object)(source.GetCurrentValue>(refTypeList))) == null ? null : ((List)(((ValueComparer)(((IProperty)refTypeList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeList))))))), (((IEnumerable)(source.GetCurrentValue(valueTypeArray))) == null ? null : ((DateTime[])(((ValueComparer>)(((IProperty)valueTypeArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(valueTypeArray))))))), (source.GetCurrentValue>(valueTypeEnumerable) == null ? null : ((ValueComparer>)(((IProperty)valueTypeEnumerable).GetValueComparer())).Snapshot(source.GetCurrentValue>(valueTypeEnumerable))), (((IEnumerable)(source.GetCurrentValue>(valueTypeIList))) == null ? null : ((IList)(((ValueComparer>)(((IProperty)valueTypeIList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeIList))))))), (((IEnumerable)(source.GetCurrentValue>(valueTypeList))) == null ? null : ((List)(((ValueComparer>)(((IProperty)valueTypeList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeList)))))))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)enum1).GetValueComparer())).Snapshot(default(CompiledModelTestBase.AnEnum)), (default(long? ) == null ? null : ((ValueComparer)(((IProperty)principalBaseId).GetValueComparer())).Snapshot(default(long? ))), (default(long? ) == null ? null : ((ValueComparer)(((IProperty)principalDerivedId).GetValueComparer())).Snapshot(default(long? ))))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(CompiledModelTestBase.AnEnum), default(long? ), default(long? ))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("PrincipalBaseId") ? ((long? )(source["PrincipalBaseId"])) : null), (source.ContainsKey("PrincipalDerivedId") ? ((long? )(source["PrincipalDerivedId"])) : null))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(long? ), default(long? ))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.PrincipalBase)(source.Entity)); + return ((ISnapshot)(new Snapshot((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))), (source.GetCurrentValue(principalBaseId) == null ? null : ((ValueComparer)(((IProperty)principalBaseId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalBaseId))), (source.GetCurrentValue(principalDerivedId) == null ? null : ((ValueComparer)(((IProperty)principalDerivedId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalDerivedId))), SnapshotFactoryFactory.SnapshotCollection(PrincipalBaseUnsafeAccessors.Deriveds(entity))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 15, + navigationCount: 1, + complexPropertyCount: 0, + originalValueCount: 15, + shadowCount: 2, + relationshipCount: 4, + storeGeneratedCount: 3); + var insertSproc = new RuntimeStoredProcedure( + runtimeEntityType, + "PrincipalBase_Insert", + "TPC", + false); + + var id0 = insertSproc.AddParameter( + "Id", System.Data.ParameterDirection.Input, false, "Id", false); + var principalBaseId0 = insertSproc.AddParameter( + "PrincipalBaseId", System.Data.ParameterDirection.Input, false, "PrincipalBaseId", false); + var principalDerivedId0 = insertSproc.AddParameter( + "PrincipalDerivedId", System.Data.ParameterDirection.Input, false, "PrincipalDerivedId", false); + var enum20 = insertSproc.AddParameter( + "Enum2", System.Data.ParameterDirection.Input, false, "Enum2", false); + var flagsEnum10 = insertSproc.AddParameter( + "FlagsEnum1", System.Data.ParameterDirection.Input, false, "FlagsEnum1", false); + var flagsEnum20 = insertSproc.AddParameter( + "FlagsEnum2", System.Data.ParameterDirection.Input, false, "FlagsEnum2", false); + var valueTypeList0 = insertSproc.AddParameter( + "ValueTypeList", System.Data.ParameterDirection.Input, false, "ValueTypeList", false); + var valueTypeIList0 = insertSproc.AddParameter( + "ValueTypeIList", System.Data.ParameterDirection.Input, false, "ValueTypeIList", false); + var valueTypeArray0 = insertSproc.AddParameter( + "ValueTypeArray", System.Data.ParameterDirection.Input, false, "ValueTypeArray", false); + var valueTypeEnumerable0 = insertSproc.AddParameter( + "ValueTypeEnumerable", System.Data.ParameterDirection.Input, false, "ValueTypeEnumerable", false); + var refTypeList0 = insertSproc.AddParameter( + "RefTypeList", System.Data.ParameterDirection.Input, false, "RefTypeList", false); + var refTypeIList0 = insertSproc.AddParameter( + "RefTypeIList", System.Data.ParameterDirection.Input, false, "RefTypeIList", false); + var refTypeArray0 = insertSproc.AddParameter( + "RefTypeArray", System.Data.ParameterDirection.Input, false, "RefTypeArray", false); + var refTypeEnumerable0 = insertSproc.AddParameter( + "RefTypeEnumerable", System.Data.ParameterDirection.Input, false, "RefTypeEnumerable", false); + var enum10 = insertSproc.AddParameter( + "BaseEnum", System.Data.ParameterDirection.Output, false, "Enum1", false); + enum10.AddAnnotation("foo", "bar"); + insertSproc.AddAnnotation("foo", "bar1"); + runtimeEntityType.AddAnnotation("Relational:InsertStoredProcedure", insertSproc); + + var deleteSproc = new RuntimeStoredProcedure( + runtimeEntityType, + "PrincipalBase_Delete", + "TPC", + false); + + var id1 = deleteSproc.AddParameter( + "Id_Original", System.Data.ParameterDirection.Input, false, "Id", true); + var rowsAffected = deleteSproc.AddParameter( + "RowsAffected", System.Data.ParameterDirection.Output, true, null, null); + runtimeEntityType.AddAnnotation("Relational:DeleteStoredProcedure", deleteSproc); + + var updateSproc = new RuntimeStoredProcedure( + runtimeEntityType, + "PrincipalBase_Update", + "TPC", + false); + + var principalBaseId1 = updateSproc.AddParameter( + "PrincipalBaseId", System.Data.ParameterDirection.Input, false, "PrincipalBaseId", false); + var principalDerivedId1 = updateSproc.AddParameter( + "PrincipalDerivedId", System.Data.ParameterDirection.Input, false, "PrincipalDerivedId", false); + var enum11 = updateSproc.AddParameter( + "Enum1", System.Data.ParameterDirection.Input, false, "Enum1", false); + var enum21 = updateSproc.AddParameter( + "Enum2", System.Data.ParameterDirection.Input, false, "Enum2", false); + var flagsEnum11 = updateSproc.AddParameter( + "FlagsEnum1", System.Data.ParameterDirection.Input, false, "FlagsEnum1", false); + var flagsEnum21 = updateSproc.AddParameter( + "FlagsEnum2", System.Data.ParameterDirection.Input, false, "FlagsEnum2", false); + var valueTypeList1 = updateSproc.AddParameter( + "ValueTypeList", System.Data.ParameterDirection.Input, false, "ValueTypeList", false); + var valueTypeIList1 = updateSproc.AddParameter( + "ValueTypeIList", System.Data.ParameterDirection.Input, false, "ValueTypeIList", false); + var valueTypeArray1 = updateSproc.AddParameter( + "ValueTypeArray", System.Data.ParameterDirection.Input, false, "ValueTypeArray", false); + var valueTypeEnumerable1 = updateSproc.AddParameter( + "ValueTypeEnumerable", System.Data.ParameterDirection.Input, false, "ValueTypeEnumerable", false); + var refTypeList1 = updateSproc.AddParameter( + "RefTypeList", System.Data.ParameterDirection.Input, false, "RefTypeList", false); + var refTypeIList1 = updateSproc.AddParameter( + "RefTypeIList", System.Data.ParameterDirection.Input, false, "RefTypeIList", false); + var refTypeArray1 = updateSproc.AddParameter( + "RefTypeArray", System.Data.ParameterDirection.Input, false, "RefTypeArray", false); + var refTypeEnumerable1 = updateSproc.AddParameter( + "RefTypeEnumerable", System.Data.ParameterDirection.Input, false, "RefTypeEnumerable", false); + var id2 = updateSproc.AddParameter( + "Id_Original", System.Data.ParameterDirection.Input, false, "Id", true); + runtimeEntityType.AddAnnotation("Relational:UpdateStoredProcedure", updateSproc); + + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:MappingStrategy", "TPC"); + runtimeEntityType.AddAnnotation("Relational:Schema", "TPC"); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "PrincipalBase"); + runtimeEntityType.AddAnnotation("Relational:ViewDefinitionSql", null); + runtimeEntityType.AddAnnotation("Relational:ViewName", "PrincipalBaseView"); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", "TPC"); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalBaseUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalBaseUnsafeAccessors.cs new file mode 100644 index 000000000..5495088ce --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalBaseUnsafeAccessors.cs @@ -0,0 +1,57 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class PrincipalBaseUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref long? Id(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.AnEnum Enum1(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.AnEnum? Enum2(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.AFlagsEnum FlagsEnum1(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref CompiledModelTestBase.AFlagsEnum FlagsEnum2(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IPAddress[] RefTypeArray(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IEnumerable RefTypeEnumerable(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IList RefTypeIList(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List RefTypeList(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref DateTime[] ValueTypeArray(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IEnumerable ValueTypeEnumerable(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref IList ValueTypeIList(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref List ValueTypeList(CompiledModelTestBase.PrincipalBase @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ICollection Deriveds(CompiledModelTestBase.PrincipalBase @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalDerivedEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalDerivedEntityType.cs new file mode 100644 index 000000000..5de45d533 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalDerivedEntityType.cs @@ -0,0 +1,182 @@ +// +using System; +using System.Collections.Generic; +using System.Net; +using System.Reflection; +using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + [EntityFrameworkInternal] + public partial class PrincipalDerivedEntityType + { + public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) + { + var runtimeEntityType = model.AddEntityType( + "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+PrincipalDerived>", + typeof(CompiledModelTestBase.PrincipalDerived>), + baseEntityType, + discriminatorValue: "PrincipalDerived>", + propertyCount: 0, + navigationCount: 2); + + return runtimeEntityType; + } + + public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) + { + var id = runtimeEntityType.FindProperty("Id"); + var enum1 = runtimeEntityType.FindProperty("Enum1"); + var enum2 = runtimeEntityType.FindProperty("Enum2"); + var flagsEnum1 = runtimeEntityType.FindProperty("FlagsEnum1"); + var flagsEnum2 = runtimeEntityType.FindProperty("FlagsEnum2"); + var principalBaseId = runtimeEntityType.FindProperty("PrincipalBaseId"); + var principalDerivedId = runtimeEntityType.FindProperty("PrincipalDerivedId"); + var refTypeArray = runtimeEntityType.FindProperty("RefTypeArray"); + var refTypeEnumerable = runtimeEntityType.FindProperty("RefTypeEnumerable"); + var refTypeIList = runtimeEntityType.FindProperty("RefTypeIList"); + var refTypeList = runtimeEntityType.FindProperty("RefTypeList"); + var valueTypeArray = runtimeEntityType.FindProperty("ValueTypeArray"); + var valueTypeEnumerable = runtimeEntityType.FindProperty("ValueTypeEnumerable"); + var valueTypeIList = runtimeEntityType.FindProperty("ValueTypeIList"); + var valueTypeList = runtimeEntityType.FindProperty("ValueTypeList"); + var deriveds = runtimeEntityType.FindNavigation("Deriveds"); + var dependent = runtimeEntityType.FindNavigation("Dependent"); + var principals = runtimeEntityType.FindNavigation("Principals"); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.PrincipalDerived>)(source.Entity)); + return ((ISnapshot)(new Snapshot, IList, List, DateTime[], IEnumerable, IList, List>((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id))), ((ValueComparer)(((IProperty)enum1).GetValueComparer())).Snapshot(source.GetCurrentValue(enum1)), (source.GetCurrentValue(enum2) == null ? null : ((ValueComparer)(((IProperty)enum2).GetValueComparer())).Snapshot(source.GetCurrentValue(enum2))), ((ValueComparer)(((IProperty)flagsEnum1).GetValueComparer())).Snapshot(source.GetCurrentValue(flagsEnum1)), ((ValueComparer)(((IProperty)flagsEnum2).GetValueComparer())).Snapshot(source.GetCurrentValue(flagsEnum2)), (source.GetCurrentValue(principalBaseId) == null ? null : ((ValueComparer)(((IProperty)principalBaseId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalBaseId))), (source.GetCurrentValue(principalDerivedId) == null ? null : ((ValueComparer)(((IProperty)principalDerivedId).GetValueComparer())).Snapshot(source.GetCurrentValue(principalDerivedId))), (((object)(source.GetCurrentValue(refTypeArray))) == null ? null : ((IPAddress[])(((ValueComparer)(((IProperty)refTypeArray).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue(refTypeArray))))))), (((object)(source.GetCurrentValue>(refTypeEnumerable))) == null ? null : ((IEnumerable)(((ValueComparer)(((IProperty)refTypeEnumerable).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeEnumerable))))))), (((object)(source.GetCurrentValue>(refTypeIList))) == null ? null : ((IList)(((ValueComparer)(((IProperty)refTypeIList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeIList))))))), (((object)(source.GetCurrentValue>(refTypeList))) == null ? null : ((List)(((ValueComparer)(((IProperty)refTypeList).GetValueComparer())).Snapshot(((object)(source.GetCurrentValue>(refTypeList))))))), (((IEnumerable)(source.GetCurrentValue(valueTypeArray))) == null ? null : ((DateTime[])(((ValueComparer>)(((IProperty)valueTypeArray).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue(valueTypeArray))))))), (source.GetCurrentValue>(valueTypeEnumerable) == null ? null : ((ValueComparer>)(((IProperty)valueTypeEnumerable).GetValueComparer())).Snapshot(source.GetCurrentValue>(valueTypeEnumerable))), (((IEnumerable)(source.GetCurrentValue>(valueTypeIList))) == null ? null : ((IList)(((ValueComparer>)(((IProperty)valueTypeIList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeIList))))))), (((IEnumerable)(source.GetCurrentValue>(valueTypeList))) == null ? null : ((List)(((ValueComparer>)(((IProperty)valueTypeList).GetValueComparer())).Snapshot(((IEnumerable)(source.GetCurrentValue>(valueTypeList)))))))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)enum1).GetValueComparer())).Snapshot(default(CompiledModelTestBase.AnEnum)), (default(long? ) == null ? null : ((ValueComparer)(((IProperty)principalBaseId).GetValueComparer())).Snapshot(default(long? ))), (default(long? ) == null ? null : ((ValueComparer)(((IProperty)principalDerivedId).GetValueComparer())).Snapshot(default(long? ))))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(CompiledModelTestBase.AnEnum), default(long? ), default(long? ))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("PrincipalBaseId") ? ((long? )(source["PrincipalBaseId"])) : null), (source.ContainsKey("PrincipalDerivedId") ? ((long? )(source["PrincipalDerivedId"])) : null))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(long? ), default(long? ))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.PrincipalDerived>)(source.Entity)); + return ((ISnapshot)(new Snapshot((source.GetCurrentValue(id) == null ? null : ((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))), (source.GetCurrentValue(principalBaseId) == null ? null : ((ValueComparer)(((IProperty)principalBaseId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalBaseId))), (source.GetCurrentValue(principalDerivedId) == null ? null : ((ValueComparer)(((IProperty)principalDerivedId).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(principalDerivedId))), SnapshotFactoryFactory.SnapshotCollection(PrincipalBaseUnsafeAccessors.Deriveds(entity)), PrincipalDerivedUnsafeAccessors>.Dependent(entity), SnapshotFactoryFactory.SnapshotCollection(PrincipalDerivedUnsafeAccessors>.Principals(entity))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 15, + navigationCount: 3, + complexPropertyCount: 0, + originalValueCount: 15, + shadowCount: 2, + relationshipCount: 6, + storeGeneratedCount: 3); + var insertSproc = new RuntimeStoredProcedure( + runtimeEntityType, + "Derived_Insert", + "TPC", + false); + + var id0 = insertSproc.AddParameter( + "Id", System.Data.ParameterDirection.Input, false, "Id", false); + var principalBaseId0 = insertSproc.AddParameter( + "PrincipalBaseId", System.Data.ParameterDirection.Input, false, "PrincipalBaseId", false); + var principalDerivedId0 = insertSproc.AddParameter( + "PrincipalDerivedId", System.Data.ParameterDirection.Input, false, "PrincipalDerivedId", false); + var enum20 = insertSproc.AddParameter( + "Enum2", System.Data.ParameterDirection.Input, false, "Enum2", false); + var flagsEnum10 = insertSproc.AddParameter( + "FlagsEnum1", System.Data.ParameterDirection.Input, false, "FlagsEnum1", false); + var flagsEnum20 = insertSproc.AddParameter( + "FlagsEnum2", System.Data.ParameterDirection.Input, false, "FlagsEnum2", false); + var valueTypeList0 = insertSproc.AddParameter( + "ValueTypeList", System.Data.ParameterDirection.Input, false, "ValueTypeList", false); + var valueTypeIList0 = insertSproc.AddParameter( + "ValueTypeIList", System.Data.ParameterDirection.Input, false, "ValueTypeIList", false); + var valueTypeArray0 = insertSproc.AddParameter( + "ValueTypeArray", System.Data.ParameterDirection.Input, false, "ValueTypeArray", false); + var valueTypeEnumerable0 = insertSproc.AddParameter( + "ValueTypeEnumerable", System.Data.ParameterDirection.Input, false, "ValueTypeEnumerable", false); + var refTypeList0 = insertSproc.AddParameter( + "RefTypeList", System.Data.ParameterDirection.Input, false, "RefTypeList", false); + var refTypeIList0 = insertSproc.AddParameter( + "RefTypeIList", System.Data.ParameterDirection.Input, false, "RefTypeIList", false); + var refTypeArray0 = insertSproc.AddParameter( + "RefTypeArray", System.Data.ParameterDirection.Input, false, "RefTypeArray", false); + var refTypeEnumerable0 = insertSproc.AddParameter( + "RefTypeEnumerable", System.Data.ParameterDirection.Input, false, "RefTypeEnumerable", false); + var derivedEnum = insertSproc.AddResultColumn( + "DerivedEnum", false, "Enum1"); + derivedEnum.AddAnnotation("foo", "bar3"); + runtimeEntityType.AddAnnotation("Relational:InsertStoredProcedure", insertSproc); + + var deleteSproc = new RuntimeStoredProcedure( + runtimeEntityType, + "Derived_Delete", + "TPC", + false); + + var id1 = deleteSproc.AddParameter( + "Id_Original", System.Data.ParameterDirection.Input, false, "Id", true); + runtimeEntityType.AddAnnotation("Relational:DeleteStoredProcedure", deleteSproc); + + var updateSproc = new RuntimeStoredProcedure( + runtimeEntityType, + "Derived_Update", + "Derived", + false); + + var principalBaseId1 = updateSproc.AddParameter( + "PrincipalBaseId", System.Data.ParameterDirection.Input, false, "PrincipalBaseId", false); + var principalDerivedId1 = updateSproc.AddParameter( + "PrincipalDerivedId", System.Data.ParameterDirection.Input, false, "PrincipalDerivedId", false); + var enum10 = updateSproc.AddParameter( + "Enum1", System.Data.ParameterDirection.Input, false, "Enum1", false); + var enum21 = updateSproc.AddParameter( + "Enum2", System.Data.ParameterDirection.Input, false, "Enum2", false); + var flagsEnum11 = updateSproc.AddParameter( + "FlagsEnum1", System.Data.ParameterDirection.Input, false, "FlagsEnum1", false); + var flagsEnum21 = updateSproc.AddParameter( + "FlagsEnum2", System.Data.ParameterDirection.Input, false, "FlagsEnum2", false); + var valueTypeList1 = updateSproc.AddParameter( + "ValueTypeList", System.Data.ParameterDirection.Input, false, "ValueTypeList", false); + var valueTypeIList1 = updateSproc.AddParameter( + "ValueTypeIList", System.Data.ParameterDirection.Input, false, "ValueTypeIList", false); + var valueTypeArray1 = updateSproc.AddParameter( + "ValueTypeArray", System.Data.ParameterDirection.Input, false, "ValueTypeArray", false); + var valueTypeEnumerable1 = updateSproc.AddParameter( + "ValueTypeEnumerable", System.Data.ParameterDirection.Input, false, "ValueTypeEnumerable", false); + var refTypeList1 = updateSproc.AddParameter( + "RefTypeList", System.Data.ParameterDirection.Input, false, "RefTypeList", false); + var refTypeIList1 = updateSproc.AddParameter( + "RefTypeIList", System.Data.ParameterDirection.Input, false, "RefTypeIList", false); + var refTypeArray1 = updateSproc.AddParameter( + "RefTypeArray", System.Data.ParameterDirection.Input, false, "RefTypeArray", false); + var refTypeEnumerable1 = updateSproc.AddParameter( + "RefTypeEnumerable", System.Data.ParameterDirection.Input, false, "RefTypeEnumerable", false); + var id2 = updateSproc.AddParameter( + "Id_Original", System.Data.ParameterDirection.Input, false, "Id", true); + runtimeEntityType.AddAnnotation("Relational:UpdateStoredProcedure", updateSproc); + + runtimeEntityType.AddAnnotation("Relational:FunctionName", null); + runtimeEntityType.AddAnnotation("Relational:Schema", "TPC"); + runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); + runtimeEntityType.AddAnnotation("Relational:TableName", "PrincipalDerived"); + runtimeEntityType.AddAnnotation("Relational:ViewDefinitionSql", null); + runtimeEntityType.AddAnnotation("Relational:ViewName", "PrincipalDerivedView"); + runtimeEntityType.AddAnnotation("Relational:ViewSchema", "TPC"); + + Customize(runtimeEntityType); + } + + static partial void Customize(RuntimeEntityType runtimeEntityType); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalDerivedUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalDerivedUnsafeAccessors.cs new file mode 100644 index 000000000..33c6bf495 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Tpc_Sprocs/PrincipalDerivedUnsafeAccessors.cs @@ -0,0 +1,20 @@ +// +using System.Collections.Generic; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class PrincipalDerivedUnsafeAccessors + where TDependent : class + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref TDependent Dependent(CompiledModelTestBase.PrincipalDerived @this); + + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref ICollection Principals(CompiledModelTestBase.PrincipalDerived @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DataEntityType.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DataEntityType.cs index 570d25fc9..41c103284 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DataEntityType.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DataEntityType.cs @@ -1,11 +1,16 @@ // using System; using System.Collections; +using System.Collections.Generic; using System.Linq; using System.Reflection; using Microsoft.EntityFrameworkCore.ChangeTracking; +using Microsoft.EntityFrameworkCore.ChangeTracking.Internal; +using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; +using Microsoft.EntityFrameworkCore.Metadata.Internal; using Microsoft.EntityFrameworkCore.Scaffolding; +using Microsoft.EntityFrameworkCore.Storage; using Pomelo.EntityFrameworkCore.MySql.Storage.Internal; #pragma warning disable 219, 612, 618 @@ -13,7 +18,8 @@ namespace TestNamespace { - internal partial class DataEntityType + [EntityFrameworkInternal] + public partial class DataEntityType { public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType baseEntityType = null) { @@ -22,7 +28,8 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas typeof(CompiledModelTestBase.Data), baseEntityType, propertyCount: 2, - keyCount: 1); + keyCount: 1, + triggerCount: 2); var id = runtimeEntityType.AddProperty( "Id", @@ -30,19 +37,32 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas valueGenerated: ValueGenerated.OnAdd, afterSaveBehavior: PropertySaveBehavior.Throw, sentinel: 0); + id.SetAccessors( + int (InternalEntityEntry entry) => (entry.FlaggedAsStoreGenerated(0) ? entry.ReadStoreGeneratedValue(0) : (entry.FlaggedAsTemporary(0) && entry.ReadShadowValue(0) == 0 ? entry.ReadTemporaryValue(0) : entry.ReadShadowValue(0))), + int (InternalEntityEntry entry) => entry.ReadShadowValue(0), + int (InternalEntityEntry entry) => entry.ReadOriginalValue(id, 0), + int (InternalEntityEntry entry) => entry.ReadRelationshipSnapshotValue(id, 0), + object (ValueBuffer valueBuffer) => valueBuffer[0]); + id.SetPropertyIndexes( + index: 0, + originalValueIndex: 0, + shadowIndex: 0, + relationshipIndex: 0, + storeGenerationIndex: 0); id.TypeMapping = MySqlIntTypeMapping.Default.Clone( comparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), keyComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v), + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v), providerValueComparer: new ValueComparer( - (int v1, int v2) => v1 == v2, - (int v) => v, - (int v) => v)); + bool (int v1, int v2) => v1 == v2, + int (int v) => v, + int (int v) => v)); + id.SetCurrentValueComparer(new EntryCurrentValueComparer(id)); id.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); var blob = runtimeEntityType.AddProperty( @@ -51,19 +71,40 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas propertyInfo: typeof(CompiledModelTestBase.Data).GetProperty("Blob", BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly), fieldInfo: typeof(CompiledModelTestBase.Data).GetField("k__BackingField", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly), nullable: true); + blob.SetGetter( + byte[] (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity), + bool (CompiledModelTestBase.Data entity) => DataUnsafeAccessors.Blob(entity) == null, + byte[] (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance), + bool (CompiledModelTestBase.Data instance) => DataUnsafeAccessors.Blob(instance) == null); + blob.SetSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetMaterializationSetter( + (CompiledModelTestBase.Data entity, byte[] value) => DataUnsafeAccessors.Blob(entity) = value); + blob.SetAccessors( + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => DataUnsafeAccessors.Blob(((CompiledModelTestBase.Data)(entry.Entity))), + byte[] (InternalEntityEntry entry) => entry.ReadOriginalValue(blob, 1), + byte[] (InternalEntityEntry entry) => entry.GetCurrentValue(blob), + object (ValueBuffer valueBuffer) => valueBuffer[1]); + blob.SetPropertyIndexes( + index: 1, + originalValueIndex: 1, + shadowIndex: -1, + relationshipIndex: -1, + storeGenerationIndex: -1); blob.TypeMapping = MySqlByteArrayTypeMapping.Default.Clone( comparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => v.GetHashCode(), - (Byte[] v) => v), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => ((object)v).GetHashCode(), + byte[] (byte[] v) => v), keyComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray()), + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray()), providerValueComparer: new ValueComparer( - (Byte[] v1, Byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals((object)v1, (object)v2), - (Byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode((object)v), - (Byte[] source) => source.ToArray())); + bool (byte[] v1, byte[] v2) => StructuralComparisons.StructuralEqualityComparer.Equals(((object)(v1)), ((object)(v2))), + int (byte[] v) => StructuralComparisons.StructuralEqualityComparer.GetHashCode(((object)(v))), + byte[] (byte[] source) => source.ToArray())); blob.AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.None); var key = runtimeEntityType.AddKey( @@ -81,6 +122,39 @@ public static RuntimeEntityType Create(RuntimeModel model, RuntimeEntityType bas public static void CreateAnnotations(RuntimeEntityType runtimeEntityType) { + var id = runtimeEntityType.FindProperty("Id"); + var blob = runtimeEntityType.FindProperty("Blob"); + var key = runtimeEntityType.FindKey(new[] { id }); + key.SetPrincipalKeyValueFactory(KeyValueFactoryFactory.CreateSimpleNonNullableFactory(key)); + key.SetIdentityMapFactory(IdentityMapFactoryFactory.CreateFactory(key)); + runtimeEntityType.SetOriginalValuesFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.Data)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(source.GetCurrentValue(id)), (source.GetCurrentValue(blob) == null ? null : ((ValueComparer)(((IProperty)blob).GetValueComparer())).Snapshot(source.GetCurrentValue(blob)))))); + }); + runtimeEntityType.SetStoreGeneratedValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetValueComparer())).Snapshot(default(int)))))); + runtimeEntityType.SetTemporaryValuesFactory( + ISnapshot (InternalEntityEntry source) => ((ISnapshot)(new Snapshot(default(int))))); + runtimeEntityType.SetShadowValuesFactory( + ISnapshot (IDictionary source) => ((ISnapshot)(new Snapshot((source.ContainsKey("Id") ? ((int)(source["Id"])) : 0))))); + runtimeEntityType.SetEmptyShadowValuesFactory( + ISnapshot () => ((ISnapshot)(new Snapshot(default(int))))); + runtimeEntityType.SetRelationshipSnapshotFactory( + ISnapshot (InternalEntityEntry source) => + { + var entity = ((CompiledModelTestBase.Data)(source.Entity)); + return ((ISnapshot)(new Snapshot(((ValueComparer)(((IProperty)id).GetKeyValueComparer())).Snapshot(source.GetCurrentValue(id))))); + }); + runtimeEntityType.Counts = new PropertyCounts( + propertyCount: 2, + navigationCount: 0, + complexPropertyCount: 0, + originalValueCount: 2, + shadowCount: 1, + relationshipCount: 1, + storeGeneratedCount: 1); runtimeEntityType.AddAnnotation("Relational:FunctionName", null); runtimeEntityType.AddAnnotation("Relational:Schema", null); runtimeEntityType.AddAnnotation("Relational:SqlQuery", null); diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DataUnsafeAccessors.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DataUnsafeAccessors.cs new file mode 100644 index 000000000..193c89702 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DataUnsafeAccessors.cs @@ -0,0 +1,16 @@ +// +using System; +using System.Runtime.CompilerServices; +using Microsoft.EntityFrameworkCore.Scaffolding; + +#pragma warning disable 219, 612, 618 +#nullable disable + +namespace TestNamespace +{ + public static class DataUnsafeAccessors + { + [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "k__BackingField")] + public static extern ref byte[] Blob(CompiledModelTestBase.Data @this); + } +} diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DbContextAssemblyAttributes.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DbContextAssemblyAttributes.cs new file mode 100644 index 000000000..c224873f6 --- /dev/null +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DbContextAssemblyAttributes.cs @@ -0,0 +1,9 @@ +// +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.Infrastructure; +using TestNamespace; + +#pragma warning disable 219, 612, 618 +#nullable disable + +[assembly: DbContextModel(typeof(DbContext), typeof(DbContextModel))] diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DbContextModelBuilder.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DbContextModelBuilder.cs index 9ab909e3e..269a8b0f2 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DbContextModelBuilder.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/Baselines/Triggers/DbContextModelBuilder.cs @@ -5,6 +5,7 @@ using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.EntityFrameworkCore.Metadata; using Microsoft.EntityFrameworkCore.Metadata.Internal; +using Microsoft.EntityFrameworkCore.Update.Internal; #pragma warning disable 219, 612, 618 #nullable disable @@ -26,7 +27,7 @@ partial void Initialize() AddAnnotation("MySql:ValueGenerationStrategy", MySqlValueGenerationStrategy.IdentityColumn); AddAnnotation("Relational:MaxIdentifierLength", 64); - AddRuntimeAnnotation("Relational:RelationalModel", CreateRelationalModel()); + AddRuntimeAnnotation("Relational:RelationalModelFactory", () => CreateRelationalModel()); } private IRelationalModel CreateRelationalModel() @@ -57,27 +58,30 @@ private IRelationalModel CreateRelationalModel() var dataTable = new Table("Data", null, relationalModel); var idColumn = new Column("Id", "int", dataTable); dataTable.Columns.Add("Id", idColumn); + idColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(idColumn); var blobColumn = new Column("Blob", "longblob", dataTable) { IsNullable = true }; dataTable.Columns.Add("Blob", blobColumn); + blobColumn.Accessors = ColumnAccessorsFactory.CreateGeneric(blobColumn); + relationalModel.Tables.Add(("Data", null), dataTable); + var dataTableMapping = new TableMapping(data, dataTable, null); + dataTable.AddTypeMapping(dataTableMapping, false); + tableMappings.Add(dataTableMapping); + RelationalModel.CreateColumnMapping(idColumn, data.FindProperty("Id")!, dataTableMapping); + RelationalModel.CreateColumnMapping(blobColumn, data.FindProperty("Blob")!, dataTableMapping); var pK_Data = new UniqueConstraint("PK_Data", dataTable, new[] { idColumn }); dataTable.PrimaryKey = pK_Data; - var pK_DataUc = RelationalModel.GetKey(this, + pK_Data.SetRowKeyValueFactory(new SimpleRowKeyValueFactory(pK_Data)); + var pK_DataKey = RelationalModel.GetKey(this, "Microsoft.EntityFrameworkCore.Scaffolding.CompiledModelTestBase+Data", new[] { "Id" }); - pK_Data.MappedKeys.Add(pK_DataUc); - RelationalModel.GetOrCreateUniqueConstraints(pK_DataUc).Add(pK_Data); + pK_Data.MappedKeys.Add(pK_DataKey); + RelationalModel.GetOrCreateUniqueConstraints(pK_DataKey).Add(pK_Data); dataTable.UniqueConstraints.Add("PK_Data", pK_Data); dataTable.Triggers.Add("Trigger1", data.FindDeclaredTrigger("Trigger1")); dataTable.Triggers.Add("Trigger2", data.FindDeclaredTrigger("Trigger2")); - relationalModel.Tables.Add(("Data", null), dataTable); - var dataTableMapping = new TableMapping(data, dataTable, null); - dataTable.AddTypeMapping(dataTableMapping, false); - tableMappings.Add(dataTableMapping); - RelationalModel.CreateColumnMapping(idColumn, data.FindProperty("Id")!, dataTableMapping); - RelationalModel.CreateColumnMapping(blobColumn, data.FindProperty("Blob")!, dataTableMapping); return relationalModel.MakeReadOnly(); } } diff --git a/test/EFCore.MySql.FunctionalTests/Scaffolding/CompiledModelMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Scaffolding/CompiledModelMySqlTest.cs index 577ef5474..c9707a1df 100644 --- a/test/EFCore.MySql.FunctionalTests/Scaffolding/CompiledModelMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Scaffolding/CompiledModelMySqlTest.cs @@ -8,6 +8,7 @@ using System; using System.Runtime.CompilerServices; using System.Text.RegularExpressions; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.ChangeTracking; using Microsoft.EntityFrameworkCore.Diagnostics; @@ -231,7 +232,9 @@ protected override void AssertBigModel(IModel model, bool jsonColumns) } } - public override void Tpc() + // TODO: 9.0 + // Check if we can use `UseSprocReturnValue` now. + public override Task Tpc_Sprocs() { // The CompiledModelRelationalTestBase implementation uses stored procedures with return values and result columns, which are not // supported in MySQL. @@ -239,10 +242,10 @@ public override void Tpc() // method (possible maintenance issue, because the class is likely to have a higher volatility), or we need to skip the stored procedure // validation to allow the unsupported stored procedure features. // We do the latter here. - Test( - BuildTpcModel, - AssertTpc, - options: new CompiledModelCodeGenerationOptions { UseNullableReferenceTypes = true }, + return Test( + BuildTpcSprocsModel, + AssertTpcSprocs, + options: new CompiledModelCodeGenerationOptions { UseNullableReferenceTypes = true, ForNativeAot = true }, addServices: s => s.AddSingleton()); } @@ -326,11 +329,19 @@ protected override void BuildComplexTypesModel(ModelBuilder modelBuilder) }); } - public override void BigModel_with_JSON_columns() + public override async Task BigModel_with_JSON_columns() { Assert.Equal( MySqlStrings.Ef7CoreJsonMappingNotSupported, - Assert.Throws(() => base.BigModel_with_JSON_columns()).Message); + (await Assert.ThrowsAsync(() => base.BigModel_with_JSON_columns())).Message); + } + + // TODO: 9.0 + // Check, if we can make this work. + public override async Task ComplexTypes() + { + var exception = await Assert.ThrowsAsync(() => base.ComplexTypes()); + Assert.Equal("The stored procedure 'dbo.PrincipalBase_Delete' cannot be configured to return the rows affected because a rows affected parameter or a rows affected result column for this stored procedure already exists.", exception.Message); } protected override TestHelpers TestHelpers => MySqlTestHelpers.Instance; diff --git a/test/EFCore.MySql.FunctionalTests/ServiceProviderPerContextFixtureBase.cs b/test/EFCore.MySql.FunctionalTests/ServiceProviderPerContextFixtureBase.cs index b898e15d7..edb8ac579 100644 --- a/test/EFCore.MySql.FunctionalTests/ServiceProviderPerContextFixtureBase.cs +++ b/test/EFCore.MySql.FunctionalTests/ServiceProviderPerContextFixtureBase.cs @@ -1,26 +1,31 @@ using System; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.TestUtilities; using Microsoft.Extensions.DependencyInjection; +using Xunit; namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests { - public abstract class ServiceProviderPerContextFixtureBase : ServiceProviderFixtureBase + public abstract class ServiceProviderPerContextFixtureBase : ServiceProviderFixtureBase, IAsyncLifetime where TContext : DbContext { protected abstract string StoreName { get; } - public TestStore TestStore { get; } + public TestStore TestStore { get; private set; } public TestSqlLoggerFactory TestSqlLoggerFactory => (TestSqlLoggerFactory)ListLoggerFactory; - public ServiceProviderPerContextFixtureBase() + public async Task InitializeAsync() { TestStore = TestStoreFactory.GetOrCreate(StoreName); // Setup database. var serviceProvider = SetupServices(); - TestStore.Initialize(serviceProvider, () => CreateContextFromServiceProvider(serviceProvider), c => Seed((TContext)c), Clean); + await TestStore.InitializeAsync(serviceProvider, () => CreateContextFromServiceProvider(serviceProvider), c => SeedAsync((TContext)c), CleanAsync); } + public Task DisposeAsync() + => Task.CompletedTask; + // We cannot use ServiceProviderFixtureBase.CreateOptions() here, because it does not accept an existing // DbContextOptionsBuilder or DbContextOptions object as a parameter, and we might already have one setup. protected virtual DbContextOptionsBuilder ConfigureOptions(IServiceProvider serviceProvider, DbContextOptionsBuilder optionsBuilder) @@ -64,12 +69,10 @@ protected virtual IServiceProvider SetupServices( public virtual TContext CreateContextFromServiceProvider(IServiceProvider serviceProvider) => (TContext)serviceProvider.GetRequiredService(typeof(TContext)); - protected virtual void Clean(DbContext context) - { - } + protected virtual Task CleanAsync(DbContext context) + => Task.CompletedTask; - protected virtual void Seed(TContext context) - { - } + protected virtual Task SeedAsync(TContext context) + => Task.CompletedTask; } } diff --git a/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestHelpers.cs b/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestHelpers.cs index 082e832fe..3ff680ad5 100644 --- a/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestHelpers.cs +++ b/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestHelpers.cs @@ -1,5 +1,8 @@ using System; using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; using Pomelo.EntityFrameworkCore.MySql.Infrastructure; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Diagnostics; @@ -11,6 +14,7 @@ using Pomelo.EntityFrameworkCore.MySql.Diagnostics.Internal; using Pomelo.EntityFrameworkCore.MySql.Infrastructure.Internal; using Pomelo.EntityFrameworkCore.MySql.Tests; +using Xunit; //ReSharper disable once CheckNamespace namespace Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities @@ -128,5 +132,63 @@ public static bool HasPrimitiveCollectionsSupport(SharedStoreFixtureBa return AppConfig.ServerVersion.Supports.JsonTable && fixture.CreateOptions().GetExtension().PrimitiveCollectionsSupport; } + + /// + /// Same implementation as EF Core base class, except that it can generate code for Task returning test without a `bool async` + /// parameter. + /// + public static void AssertAllMethodsOverridden(Type testClass, bool withAssertSqlCall = true) + { + var methods = testClass + .GetRuntimeMethods() + .Where( + m => m.DeclaringType != testClass + && (Attribute.IsDefined(m, typeof(ConditionalFactAttribute)) + || Attribute.IsDefined(m, typeof(ConditionalTheoryAttribute)))) + .ToList(); + + var methodCalls = new StringBuilder(); + + foreach (var method in methods) + { + if (method.ReturnType == typeof(Task)) + { + var parameters = method.GetParameters(); + var generateAsyncParameter = parameters.Length == 1 && + parameters[0].ParameterType == typeof(bool); + methodCalls.Append( + @$"public override async Task {method.Name}({(generateAsyncParameter ? "bool async" : null)}) +{{ + await base.{method.Name}({(generateAsyncParameter ? "async" : null)});{(withAssertSqlCall ? +""" + + + AssertSql(); +""" : null)} +}} + +"); + } + else + { + methodCalls.Append( + @$"public override void {method.Name}() +{{ + base.{method.Name}();{(withAssertSqlCall ? +""" + + + AssertSql(); +""" : null)} +}} + +"); + } + } + + Assert.False( + methods.Count > 0, + "\r\n-- Missing test overrides --\r\n\r\n" + methodCalls); + } } } diff --git a/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestMigrator.cs b/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestMigrator.cs index 561dc7ccc..8aea3d785 100644 --- a/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestMigrator.cs +++ b/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestMigrator.cs @@ -2,10 +2,10 @@ using System; using System.Collections.Generic; -using JetBrains.Annotations; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Diagnostics; using Microsoft.EntityFrameworkCore.Infrastructure; +using Microsoft.EntityFrameworkCore.Metadata; using Microsoft.EntityFrameworkCore.Migrations; using Microsoft.EntityFrameworkCore.Storage; using Pomelo.EntityFrameworkCore.MySql.Migrations.Internal; @@ -17,19 +17,23 @@ public class MySqlTestMigrator : MySqlMigrator public Func MigrationsSqlGenerationOptionsOverrider { get; set; } public MySqlTestMigrator( - [NotNull] IMigrationsAssembly migrationsAssembly, - [NotNull] IHistoryRepository historyRepository, - [NotNull] IDatabaseCreator databaseCreator, - [NotNull] IMigrationsSqlGenerator migrationsSqlGenerator, - [NotNull] IRawSqlCommandBuilder rawSqlCommandBuilder, - [NotNull] IMigrationCommandExecutor migrationCommandExecutor, - [NotNull] IRelationalConnection connection, - [NotNull] ISqlGenerationHelper sqlGenerationHelper, - [NotNull] ICurrentDbContext currentContext, - [NotNull] IModelRuntimeInitializer modelRuntimeInitializer, - [NotNull] IDiagnosticsLogger logger, - [NotNull] IRelationalCommandDiagnosticsLogger commandLogger, - [NotNull] IDatabaseProvider databaseProvider) + IMigrationsAssembly migrationsAssembly, + IHistoryRepository historyRepository, + IDatabaseCreator databaseCreator, + IMigrationsSqlGenerator migrationsSqlGenerator, + IRawSqlCommandBuilder rawSqlCommandBuilder, + IMigrationCommandExecutor migrationCommandExecutor, + IRelationalConnection connection, + ISqlGenerationHelper sqlGenerationHelper, + ICurrentDbContext currentContext, + IModelRuntimeInitializer modelRuntimeInitializer, + IDiagnosticsLogger logger, + IRelationalCommandDiagnosticsLogger commandLogger, + IDatabaseProvider databaseProvider, + IMigrationsModelDiffer migrationsModelDiffer, + IDesignTimeModel designTimeModel, + IDbContextOptions contextOptions, + IExecutionStrategy executionStrategy) : base( migrationsAssembly, historyRepository, @@ -43,7 +47,11 @@ public MySqlTestMigrator( modelRuntimeInitializer, logger, commandLogger, - databaseProvider) + databaseProvider, + migrationsModelDiffer, + designTimeModel, + contextOptions, + executionStrategy) { } diff --git a/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestStore.cs b/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestStore.cs index 0b8fe7a76..de10d36bf 100644 --- a/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestStore.cs +++ b/test/EFCore.MySql.FunctionalTests/TestUtilities/MySqlTestStore.cs @@ -21,6 +21,7 @@ public class MySqlTestStore : RelationalTestStore public const int DefaultCommandTimeout = 600; + private readonly string _connectionString; private readonly string _scriptPath; private readonly bool _useConnectionString; private readonly bool _noBackslashEscapes; @@ -34,20 +35,20 @@ public static MySqlTestStore GetOrCreate(string name, bool useConnectionString = public static MySqlTestStore GetOrCreate(string name, string scriptPath, bool noBackslashEscapes = false, string databaseCollation = null, MySqlGuidFormat guidFormat = MySqlGuidFormat.Default) => new MySqlTestStore(name, scriptPath: scriptPath, noBackslashEscapes: noBackslashEscapes, databaseCollation: databaseCollation, guidFormat: guidFormat); - public static MySqlTestStore GetOrCreateInitialized(string name) - => new MySqlTestStore(name, shared: true).InitializeMySql(null, (Func)null, null); + public static Task GetOrCreateInitializedAsync(string name) + => new MySqlTestStore(name, shared: true).InitializeMySqlAsync(null, (Func)null, null); public static MySqlTestStore Create(string name, bool useConnectionString = false, bool noBackslashEscapes = false, string databaseCollation = null, MySqlGuidFormat guidFormat = MySqlGuidFormat.Default) => new MySqlTestStore(name, useConnectionString: useConnectionString, shared: false, noBackslashEscapes: noBackslashEscapes, databaseCollation: databaseCollation, guidFormat: guidFormat); - public static MySqlTestStore CreateInitialized(string name) - => new MySqlTestStore(name, shared: false).InitializeMySql(null, null, null); + public static Task CreateInitializedAsync(string name) + => new MySqlTestStore(name, shared: false).InitializeMySqlAsync(null, null, null); - public static MySqlTestStore RecreateInitialized(string name) - => new MySqlTestStore(name, shared: false).InitializeMySql(null, null, null, c => + public static Task RecreateInitializedAsync(string name) + => new MySqlTestStore(name, shared: false).InitializeMySqlAsync(null, null, null, async c => { - c.Database.EnsureDeleted(); - c.Database.EnsureCreated(); + await c.Database.EnsureDeletedAsync(); + await c.Database.EnsureCreatedAsync(); }); public Lazy ServerVersion { get; } @@ -64,12 +65,16 @@ private MySqlTestStore( bool shared = true, bool noBackslashEscapes = false, MySqlGuidFormat guidFormat = MySqlGuidFormat.Default) - : base(name, shared) + : base(name, shared, new MySqlConnection(CreateConnectionString(name, noBackslashEscapes, guidFormat))) { _useConnectionString = useConnectionString; _noBackslashEscapes = noBackslashEscapes; - ConnectionString = CreateConnectionString(name, _noBackslashEscapes, guidFormat); - Connection = new MySqlConnection(ConnectionString); + + if (useConnectionString) + { + _connectionString = CreateConnectionString(name, _noBackslashEscapes, guidFormat); + } + ServerVersion = new Lazy(() => Microsoft.EntityFrameworkCore.ServerVersion.AutoDetect((MySqlConnection)Connection)); DatabaseCharSet = databaseCharSet ?? "utf8mb4"; DatabaseCollation = databaseCollation ?? ServerVersion.Value.DefaultUtf8CsCollation; @@ -98,7 +103,7 @@ public static string CreateConnectionString(string name, bool noBackslashEscapes public override DbContextOptionsBuilder AddProviderOptions(DbContextOptionsBuilder builder) => _useConnectionString - ? builder.UseMySql(ConnectionString, AppConfig.ServerVersion, x => AddOptions(x, _noBackslashEscapes)) + ? builder.UseMySql(_connectionString, AppConfig.ServerVersion, x => AddOptions(x, _noBackslashEscapes)) : builder.UseMySql(Connection, AppConfig.ServerVersion, x => AddOptions(x, _noBackslashEscapes)); public static MySqlDbContextOptionsBuilder AddOptions(MySqlDbContextOptionsBuilder builder) @@ -122,12 +127,15 @@ public static void AddOptions(MySqlDbContextOptionsBuilder builder, bool noBacks } } - public MySqlTestStore InitializeMySql(IServiceProvider serviceProvider, Func createContext, Action seed, Action clean = null) - => (MySqlTestStore)Initialize(serviceProvider, createContext, seed, clean); + public async Task InitializeMySqlAsync(IServiceProvider serviceProvider, Func createContext, Func seed, Func clean = null) + => (MySqlTestStore)await InitializeAsync(serviceProvider, createContext, seed, clean); - protected override void Initialize(Func createContext, Action seed, Action clean) + protected override async Task InitializeAsync( + Func createContext, + Func seed, + Func clean) { - if (CreateDatabase(clean)) + if (await CreateDatabaseAsync(clean)) { if (_scriptPath != null) { @@ -135,22 +143,26 @@ protected override void Initialize(Func createContext, Action clean) + private async Task CreateDatabaseAsync(Func clean) { - using var master = new MySqlConnection(CreateAdminConnectionString()); - master.Open(); + await using var master = new MySqlConnection(CreateAdminConnectionString()); + await master.OpenAsync(); string databaseSetupSql; - if (DatabaseExists(Name)) + if (await DatabaseExistsAsync(Name)) { // if (_scriptPath != null // && !TestEnvironment.IsCI) @@ -158,14 +170,18 @@ private bool CreateDatabase(Action clean) // return false; // } - using (var context = new DbContext( - AddProviderOptions( - new DbContextOptionsBuilder() - .EnableServiceProviderCaching(false)) - .Options)) + await using (var context = new DbContext( + AddProviderOptions( + new DbContextOptionsBuilder() + .EnableServiceProviderCaching(false)) + .Options)) { - clean?.Invoke(context); - Clean(context); + if (clean != null) + { + await clean(context); + } + + await CleanAsync(context); } databaseSetupSql = GetAlterDatabaseStatement(Name, DatabaseCharSet, DatabaseCollation); @@ -178,7 +194,7 @@ private bool CreateDatabase(Action clean) databaseSetupSql = GetCreateDatabaseStatement(Name, DatabaseCharSet, DatabaseCollation); } - ExecuteNonQuery(master, databaseSetupSql); + await ExecuteNonQueryAsync(master, databaseSetupSql); return true; } @@ -195,10 +211,10 @@ private static string GetCreateDatabaseStatement(string name, string charset = n private static string GetAlterDatabaseStatement(string name, string charset = null, string collation = null) => $@"ALTER DATABASE `{name}`{(string.IsNullOrEmpty(charset) ? null : $" CHARACTER SET {charset}")}{(string.IsNullOrEmpty(collation) ? null : $" COLLATE {collation}")};"; - private static bool DatabaseExists(string name) + private static async Task DatabaseExistsAsync(string name) { - using (var master = new MySqlConnection(CreateAdminConnectionString())) - return ExecuteScalar(master, $@"SELECT COUNT(*) FROM `INFORMATION_SCHEMA`.`SCHEMATA` WHERE `SCHEMA_NAME` = '{name}';") > 0; + await using var master = new MySqlConnection(CreateAdminConnectionString()); + return await ExecuteScalarAsync(master, $@"SELECT COUNT(*) FROM `INFORMATION_SCHEMA`.`SCHEMATA` WHERE `SCHEMA_NAME` = '{name}';") > 0; } private static string CreateAdminConnectionString() @@ -223,17 +239,31 @@ public void ExecuteScript(string script) return 0; }, string.Empty); - public override void Clean(DbContext context) - => context.Database.EnsureClean(); + public override Task CleanAsync(DbContext context) + { + context.Database.EnsureClean(); + return Task.CompletedTask; + } private static T ExecuteScalar(DbConnection connection, string sql, params object[] parameters) => Execute(connection, command => (T)command.ExecuteScalar(), sql, false, parameters); + private static Task ExecuteScalarAsync(DbConnection connection, string sql, params object[] parameters) + => ExecuteAsync(connection, async command => (T)(await command.ExecuteScalarAsync()), sql, false, parameters); + private static T Execute( DbConnection connection, Func execute, string sql, bool useTransaction = false, object[] parameters = null) => ExecuteCommand(connection, execute, sql, useTransaction, parameters); + private static Task ExecuteAsync( + DbConnection connection, + Func> execute, + string sql, + bool useTransaction = false, + object[] parameters = null) + => ExecuteCommandAsync(connection, execute, sql, useTransaction, parameters); + private static T ExecuteCommand( DbConnection connection, Func execute, string sql, bool useTransaction, object[] parameters) { @@ -271,12 +301,62 @@ private static T ExecuteCommand( } } + private static async Task ExecuteCommandAsync( + DbConnection connection, + Func> execute, + string sql, + bool useTransaction, + object[] parameters) + { + if (connection.State != ConnectionState.Closed) + { + await connection.CloseAsync(); + } + + await connection.OpenAsync(); + + try + { + await using (var transaction = useTransaction + ? await connection.BeginTransactionAsync() + : null) + { + T result; + await using (var command = CreateCommand(connection, sql, parameters)) + { + command.Transaction = transaction; + result = await execute(command); + } + + if (transaction != null) + { + await transaction.CommitAsync(); + } + + return result; + } + } + finally + { + if (connection.State != ConnectionState.Closed) + { + await connection.CloseAsync(); + } + } + } + public int ExecuteNonQuery(string sql, params object[] parameters) => ExecuteNonQuery(Connection, sql, parameters); + public Task ExecuteNonQueryAsync(string sql, params object[] parameters) + => ExecuteNonQueryAsync(Connection, sql, parameters); + private static int ExecuteNonQuery(DbConnection connection, string sql, object[] parameters = null) => Execute(connection, command => command.ExecuteNonQuery(), sql, false, parameters); + private static Task ExecuteNonQueryAsync(DbConnection connection, string sql, object[] parameters = null) + => ExecuteAsync(connection, command => command.ExecuteNonQueryAsync(), sql, false, parameters); + public override void OpenConnection() { base.OpenConnection(); diff --git a/test/EFCore.MySql.FunctionalTests/TransactionMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/TransactionMySqlTest.cs index 165f5a0b6..e656e2db2 100644 --- a/test/EFCore.MySql.FunctionalTests/TransactionMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/TransactionMySqlTest.cs @@ -1,4 +1,5 @@ using System; +using System.Threading.Tasks; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; @@ -35,14 +36,14 @@ public class TransactionMySqlFixture : TransactionFixtureBase { protected override ITestStoreFactory TestStoreFactory => MySqlTestStoreFactory.Instance; - public override void Reseed() + public override async Task ReseedAsync() { - using var context = CreateContext(); + await using var context = CreateContext(); context.Set().RemoveRange(context.Set()); context.Set().RemoveRange(context.Set()); - context.SaveChanges(); + await context.SaveChangesAsync(); - base.Seed(context); + await base.SeedAsync(context); } public override DbContextOptionsBuilder AddOptions(DbContextOptionsBuilder builder) diff --git a/test/EFCore.MySql.FunctionalTests/Update/StoredProcedureUpdateMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/Update/StoredProcedureUpdateMySqlTest.cs index 0aa49ce43..069bba7db 100644 --- a/test/EFCore.MySql.FunctionalTests/Update/StoredProcedureUpdateMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/Update/StoredProcedureUpdateMySqlTest.cs @@ -633,13 +633,13 @@ private async Task SaveChanges(DbContext context, bool async) } } - protected override void CreateStoredProcedures(DbContext context, string createSprocSql) + protected override async Task CreateStoredProcedures(DbContext context, string createSprocSql) { foreach (var batch in new Regex(@"[\r\n\s]*(?:\r|\n)GO;?[\r\n\s]*", RegexOptions.IgnoreCase | RegexOptions.Singleline, TimeSpan.FromMilliseconds(1000.0)) .Split(createSprocSql).Where(b => !string.IsNullOrEmpty(b))) { - context.Database.ExecuteSqlRaw(batch); + await context.Database.ExecuteSqlRawAsync(batch); } } diff --git a/test/EFCore.MySql.FunctionalTests/UpdatesMySqlTest.cs b/test/EFCore.MySql.FunctionalTests/UpdatesMySqlTest.cs index 616b3ece9..c03d41413 100644 --- a/test/EFCore.MySql.FunctionalTests/UpdatesMySqlTest.cs +++ b/test/EFCore.MySql.FunctionalTests/UpdatesMySqlTest.cs @@ -1,5 +1,6 @@ using System; using System.Linq; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.TestModels.UpdatesModel; using Microsoft.EntityFrameworkCore.TestUtilities; @@ -36,9 +37,9 @@ public override void Identifiers_are_generated_correctly() [SupportedServerVersionCondition(nameof(ServerVersionSupport.DefaultExpression), nameof(ServerVersionSupport.AlternativeDefaultExpression))] [SupportedServerVersionCondition(nameof(ServerVersionSupport.Returning))] - public override void Save_with_shared_foreign_key() + public override Task Save_with_shared_foreign_key() { - base.Save_with_shared_foreign_key(); + return base.Save_with_shared_foreign_key(); } public class UpdatesMySqlFixture : UpdatesRelationalFixture diff --git a/test/EFCore.MySql.FunctionalTests/config.json.example b/test/EFCore.MySql.FunctionalTests/config.json.example index c944e6fa7..edea7f396 100644 --- a/test/EFCore.MySql.FunctionalTests/config.json.example +++ b/test/EFCore.MySql.FunctionalTests/config.json.example @@ -1,6 +1,6 @@ { "Data": { - "ConnectionString": "server=127.0.0.1;user id=root;password=Password12!;port=3306;sslmode=none;", + "ConnectionString": "server=127.0.0.1;user id=root;password=Password12!;port=3306;sslmode=none;maxpoolsize=200;", "ServerVersion": "auto", "CommandTimeout": "600" } diff --git a/test/EFCore.MySql.IntegrationTests/EFCore.MySql.IntegrationTests.csproj b/test/EFCore.MySql.IntegrationTests/EFCore.MySql.IntegrationTests.csproj index 469bc3923..9e1dc4747 100644 --- a/test/EFCore.MySql.IntegrationTests/EFCore.MySql.IntegrationTests.csproj +++ b/test/EFCore.MySql.IntegrationTests/EFCore.MySql.IntegrationTests.csproj @@ -22,9 +22,6 @@ - - - diff --git a/test/EFCore.MySql.Tests/Behaviors/HavingBehavior.cs b/test/EFCore.MySql.Tests/Behaviors/HavingBehavior.cs new file mode 100644 index 000000000..fb8eac9b8 --- /dev/null +++ b/test/EFCore.MySql.Tests/Behaviors/HavingBehavior.cs @@ -0,0 +1,140 @@ +using System; +using Microsoft.EntityFrameworkCore; +using MySqlConnector; +using Xunit; +using Xunit.Abstractions; + +namespace Pomelo.EntityFrameworkCore.MySql.Behaviors; + +// See https://bugs.mysql.com/bug.php?id=103961. +public class HavingBehavior : RawSqlTestWithFixture +{ + public HavingBehavior(HavingBehaviorFixture fixture, ITestOutputHelper testOutputHelper) + : base(fixture) + { + } + + [Fact] + public void Having_without_aggregate_with_function_throws() + { + using var command = Connection.CreateCommand(); + command.CommandText = """ +SELECT EXTRACT(year FROM `i`.`BestServedBefore`) AS `Year`, COUNT(*) AS `Count` +FROM `IceCreams` AS `i` +GROUP BY EXTRACT(year FROM `i`.`BestServedBefore`) +HAVING EXTRACT(year FROM `i`.`BestServedBefore`) < 2030 +ORDER BY COUNT(*) DESC +"""; + + var exception = Assert.Throws(() => { using var dataReader = command.ExecuteReader(); }); + Assert.Contains("Unknown column", exception.Message); + } + + [Fact] + public void Having_without_aggregate_with_function_using_projection_reference() + { + using var command = Connection.CreateCommand(); + command.CommandText = """ +SELECT EXTRACT(year FROM `i`.`BestServedBefore`) AS `Year`, COUNT(*) AS `Count` +FROM `IceCreams` AS `i` +GROUP BY EXTRACT(year FROM `i`.`BestServedBefore`) +HAVING `Year` < 2030 +ORDER BY COUNT(*) DESC +"""; + + using var dataReader = command.ExecuteReader(); + + Assert.True(dataReader.Read()); + Assert.Equal((int)dataReader["Year"], 2025); + Assert.Equal((long)dataReader["Count"], 2); + Assert.False(dataReader.Read()); + } + + [Fact] + public void Having_without_aggregate_with_column_throws() + { + using var command = Connection.CreateCommand(); + command.CommandText = """ +SELECT EXTRACT(year FROM `i`.`BestServedBefore`) AS `Year`, COUNT(*) AS `Count` +FROM `IceCreams` AS `i` +GROUP BY EXTRACT(year FROM `i`.`BestServedBefore`) +HAVING `i`.`BestServedBefore` < '2030-01-01' +ORDER BY COUNT(*) DESC +"""; + + var exception = Assert.Throws(() => { using var dataReader = command.ExecuteReader(); }); + Assert.Contains("Unknown column", exception.Message); + } + + [Fact] + public void Having_without_aggregate_with_column_using_projection_reference() + { + using var command = Connection.CreateCommand(); + command.CommandText = """ +SELECT EXTRACT(year FROM `i`.`BestServedBefore`) AS `Year`, COUNT(*) AS `Count`, `i`.`BestServedBefore` < '2030-01-01' AS `having` +FROM `IceCreams` AS `i` +GROUP BY EXTRACT(year FROM `i`.`BestServedBefore`), `i`.`BestServedBefore` < '2030-01-01' +HAVING `having` +ORDER BY COUNT(*) DESC +"""; + + using var dataReader = command.ExecuteReader(); + + Assert.True(dataReader.Read()); + Assert.Equal((int)dataReader["Year"], 2025); + Assert.Equal((long)dataReader["Count"], 2); + Assert.False(dataReader.Read()); + } + + [Fact] + public void Having_without_aggregate_with_constant() + { + using var command = Connection.CreateCommand(); + command.CommandText = """ +SELECT EXTRACT(year FROM `i`.`BestServedBefore`) AS `Year`, COUNT(*) AS `Count` +FROM `IceCreams` AS `i` +GROUP BY EXTRACT(year FROM `i`.`BestServedBefore`) +HAVING TRUE +ORDER BY COUNT(*) DESC +"""; + + using var dataReader = command.ExecuteReader(); + + Assert.True(dataReader.Read()); + Assert.Equal((int)dataReader["Year"], 2025); + Assert.Equal((long)dataReader["Count"], 2); + Assert.True(dataReader.Read()); + Assert.Equal((int)dataReader["Year"], 2036); + Assert.Equal((long)dataReader["Count"], 1); + Assert.False(dataReader.Read()); + } + + public static class Model + { + public class IceCream + { + public int IceCreamId { get; set; } + public string Name { get; set; } + public DateTime BestServedBefore { get; set; } + } + + public class HavingBehaviorContext : ContextBase + { + public DbSet IceCreams { get; set; } + + protected override void OnModelCreating(ModelBuilder modelBuilder) + { + modelBuilder.Entity( + entity => + { + entity.HasData( + new IceCream { IceCreamId = 1, Name = "Vanilla", BestServedBefore = new DateTime(2025, 6, 1)}, + new IceCream { IceCreamId = 2, Name = "Chocolate", BestServedBefore = new DateTime(2025, 6, 1)}, + new IceCream { IceCreamId = 3, Name = "Matcha", BestServedBefore = new DateTime(2036, 1, 1)}); + }); + } + } + } + + public class HavingBehaviorFixture : MySqlTestFixtureBase; +} diff --git a/test/EFCore.MySql.Tests/MySqlTestFixtureBase.cs b/test/EFCore.MySql.Tests/MySqlTestFixtureBase.cs index 1a34e6f6a..b47d3f5b2 100644 --- a/test/EFCore.MySql.Tests/MySqlTestFixtureBase.cs +++ b/test/EFCore.MySql.Tests/MySqlTestFixtureBase.cs @@ -1,9 +1,11 @@ using System; using System.Collections.Generic; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Microsoft.Extensions.DependencyInjection; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; +using Xunit; namespace Pomelo.EntityFrameworkCore.MySql { @@ -24,33 +26,42 @@ public void Dispose() } public class MySqlTestFixtureBase - : MySqlTestFixtureBase + : MySqlTestFixtureBase, IAsyncLifetime where TContext : ContextBase, new() { + private readonly bool _initializeEmpty; private const string FixtureSuffix = "Fixture"; public MySqlTestFixtureBase(bool initializeEmpty = false) + { + _initializeEmpty = initializeEmpty; + } + + public async Task InitializeAsync() { // We branch here, because CreateDefaultDbContext depends on TestStore.Name by default, which would not be available yet in // the MySqlTestStore.RecreateInitialized(StoreName) call. - if (initializeEmpty) + if (_initializeEmpty) { - TestStore = MySqlTestStore.RecreateInitialized(StoreName); + TestStore = await MySqlTestStore.RecreateInitializedAsync(StoreName); } else { TestStore = MySqlTestStore.Create(StoreName); - TestStore.InitializeMySql(null, CreateDefaultDbContext, null, c => + await TestStore.InitializeMySqlAsync(null, CreateDefaultDbContext, null, async c => { - c.Database.EnsureDeleted(); - c.Database.EnsureCreated(); + await c.Database.EnsureDeletedAsync(); + await c.Database.EnsureCreatedAsync(); }); } SetupDatabase(); } + public Task DisposeAsync() + => Task.CompletedTask; + protected override void Dispose(bool disposing) { TestStore.Dispose(); @@ -68,7 +79,7 @@ protected virtual string StoreName } } - protected virtual MySqlTestStore TestStore { get; } + protected virtual MySqlTestStore TestStore { get; private set; } protected virtual string SetupDatabaseScript { get; } protected virtual List SqlCommands { get; } = new List(); protected virtual string Sql => string.Join("\n\n", SqlCommands); diff --git a/test/EFCore.MySql.Tests/Query/MySqlCollationTest.cs b/test/EFCore.MySql.Tests/Query/MySqlCollationTest.cs index 7e12ae88e..14b32604b 100644 --- a/test/EFCore.MySql.Tests/Query/MySqlCollationTest.cs +++ b/test/EFCore.MySql.Tests/Query/MySqlCollationTest.cs @@ -1,6 +1,7 @@ using System.Linq; using Microsoft.EntityFrameworkCore; using MySqlConnector; +using Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes; using Xunit; namespace Pomelo.EntityFrameworkCore.MySql.Query @@ -12,6 +13,10 @@ public MySqlCollationTest(MySqlCollationFixture fixture) { } + // TODO: 9.0 + // For some reason, this test does not throw on MariaDB 11.5 (Ubuntu/Windows) or MariaDB 11.4 Ubuntu (but throws on Windows). + // The test is supposed to throw. + [SupportedServerVersionLessThanCondition("11.4.0-mariadb")] [ConditionalFact] public void Where_with_incompatible_collations_fails() { @@ -22,6 +27,22 @@ public void Where_with_incompatible_collations_fails() var connection = (MySqlConnection)context.Database.GetDbConnection(); var csb = new MySqlConnectionStringBuilder(connection.ConnectionString); + // using (var command = connection.CreateCommand()) + // { + // command.CommandText = "SELECT @@character_set_server, @@collation_server, @@character_set_client, @@character_set_connection, @@collation_connection"; + // using (var reader = command.ExecuteReader()) + // { + // if (reader.Read()) + // { + // var character_set_server = (string)reader["@@character_set_server"]; + // var collation_server = (string)reader["@@collation_server"]; + // var character_set_client = (string)reader["@@character_set_client"]; + // var character_set_connection = (string)reader["@@character_set_connection"]; + // var collation_connection = (string)reader["@@collation_connection"]; + // } + // } + // } + Assert.Throws( () => context.Set() .Where(e => EF.Functions.Like(e.Name + e.Number, "%Metal%")) diff --git a/test/EFCore.MySql.Tests/TestBase.cs b/test/EFCore.MySql.Tests/TestBase.cs index f1b9e0f9b..8d4f2eaa7 100644 --- a/test/EFCore.MySql.Tests/TestBase.cs +++ b/test/EFCore.MySql.Tests/TestBase.cs @@ -1,28 +1,32 @@ using System; using System.Collections.Generic; +using System.Threading.Tasks; using Microsoft.EntityFrameworkCore; using Microsoft.EntityFrameworkCore.Infrastructure; using Pomelo.EntityFrameworkCore.MySql.FunctionalTests.TestUtilities; +using Xunit; namespace Pomelo.EntityFrameworkCore.MySql { - public class TestBase : IDisposable + public class TestBase : IDisposable, IAsyncLifetime where TContext : ContextBase, new() { - public TestBase() + public async Task InitializeAsync() { - TestStore = MySqlTestStore.CreateInitialized(StoreName); + TestStore = await MySqlTestStore.CreateInitializedAsync(StoreName); } + public Task DisposeAsync() + => Task.CompletedTask; + public virtual void Dispose() => TestStore.Dispose(); public virtual string StoreName => GetType().Name; - public virtual MySqlTestStore TestStore { get; } + public virtual MySqlTestStore TestStore { get; private set; } public virtual List SqlCommands { get; } = new List(); public virtual string Sql => string.Join("\n\n", SqlCommands); - public virtual TContext CreateContext( - Action jetOptions = null, + public virtual async Task CreateContext(Action jetOptions = null, Action options = null, Action model = null) { @@ -35,7 +39,7 @@ public virtual TContext CreateContext( options: options, mySqlOptions: jetOptions); - TestStore.Clean(context); + await TestStore.CleanAsync(context); return context; } diff --git a/test/Shared/TestUtilities/Attributes/SupportedServerVersionBetweenConditionAttribute.cs b/test/Shared/TestUtilities/Attributes/SupportedServerVersionBetweenConditionAttribute.cs new file mode 100644 index 000000000..10fe728de --- /dev/null +++ b/test/Shared/TestUtilities/Attributes/SupportedServerVersionBetweenConditionAttribute.cs @@ -0,0 +1,47 @@ +using System; +using System.Threading.Tasks; +using Microsoft.EntityFrameworkCore; +using Microsoft.EntityFrameworkCore.TestUtilities.Xunit; + +namespace Pomelo.EntityFrameworkCore.MySql.Tests.TestUtilities.Attributes +{ + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)] + public class SupportedServerVersionBetweenConditionAttribute : Attribute, ITestCondition + { + public ServerVersion MinVersionInclusive { get; } + public ServerVersion MaxVersionExclusive { get; } + + public SupportedServerVersionBetweenConditionAttribute(string minVersionInclusive, string maxVersionExclusive) + { + MinVersionInclusive = ServerVersion.Parse(minVersionInclusive); + MaxVersionExclusive = ServerVersion.Parse(maxVersionExclusive); + } + + public virtual ValueTask IsMetAsync() + { + var currentVersion = AppConfig.ServerVersion; + var isMet = currentVersion.Type == MinVersionInclusive.Type && + currentVersion.TypeIdentifier == MinVersionInclusive.TypeIdentifier && + currentVersion.Version >= MinVersionInclusive.Version && + currentVersion.Type == MaxVersionExclusive.Type && + currentVersion.TypeIdentifier == MaxVersionExclusive.TypeIdentifier && + currentVersion.Version < MaxVersionExclusive.Version; + + if (Invert) + { + isMet = !isMet; + } + + if (!isMet && string.IsNullOrEmpty(Skip)) + { + Skip = $"The test is not supported on server version {currentVersion}."; + } + + return new ValueTask(isMet); + } + + public virtual string SkipReason => Skip; + public virtual string Skip { get; set; } + public virtual bool Invert { get; set; } + } +} diff --git a/tools/QueryBaselineUpdater/Program.cs b/tools/QueryBaselineUpdater/Program.cs index e23e2bced..15ae5504f 100644 --- a/tools/QueryBaselineUpdater/Program.cs +++ b/tools/QueryBaselineUpdater/Program.cs @@ -8,7 +8,7 @@ namespace QueryBaselineUpdater { internal static class Program { - private const string AssertSqlPattern = @"\s*Assert(?:ExecuteUpdate)?Sql\(\s*(?:(?:@?(""""""|"")).*?\1)?\);\r?\n"; + private const string AssertSqlPattern = @"(?\s*)Assert(?:ExecuteUpdate)?Sql\(\s*(?:(?:@?(""""""|"")).*?\1)?\);\r?\n"; private static int Main(string[] args) { @@ -85,7 +85,7 @@ private static int Main(string[] args) retryCustomized, f => f.Id, s => s, - (inner, _) => inner) + (outer, _) => outer) .OrderByDescending(t => t.Line) .Aggregate( File.ReadAllText(customizedFilePath), @@ -122,7 +122,7 @@ private static string ReplaceChunk(string result, AssertSqlChunk current, List