MySQLPropertyExtensions

We found 5 examples in language CSharp for this search. You will see 30 fragments of code.
        /// <summary>
        ///     <para>
        ///         Returns the <see cref="SqlServerValueGenerationStrategy" /> to use for the property.
        ///     </para>
        ///     <para>
        ///         If no strategy is set for the property, then the strategy to use will be taken from the <see cref="IModel" />.
        ///     </para>
        /// </summary>
        /// <returns> The strategy, or <see cref="SqlServerValueGenerationStrategy.None"/> if none was set. </returns>
        public static MySqlValueGenerationStrategy? GetValueGenerationStrategy([NotNull] this IProperty property)
        {
            var annotation = property[MySqlAnnotationNames.ValueGenerationStrategy];
            if (annotation != null)
            {
                return (MySqlValueGenerationStrategy?)annotation;
            }

            if (property.GetDefaultValue() != null
                || property.GetDefaultValueSql() != null
                || property.GetComputedColumnSql() != null)
            {
                return null;
            }

            if (property.ValueGenerated == ValueGenerated.Never)
            {
                var sharedTablePrincipalPrimaryKeyProperty = property.FindSharedTableRootPrimaryKeyProperty();
                return sharedTablePrincipalPrimaryKeyProperty?.GetValueGenerationStrategy();
            }

            if (IsCompatibleIdentityColumn(property) && property.ValueGenerated == ValueGenerated.OnAdd)
            {
                return MySqlValueGenerationStrategy.IdentityColumn;
            }

            if (IsCompatibleComputedColumn(property) && property.ValueGenerated == ValueGenerated.OnAddOrUpdate)
            {
                return MySqlValueGenerationStrategy.ComputedColumn;
            }

            return null;
        }

        /// <summary>
        ///     Sets the <see cref="SqlServerValueGenerationStrategy" /> to use for the property.
        /// </summary>
        /// <param name="property"> The property. </param>
        /// <param name="value"> The strategy to use. </param>
        public static void SetValueGenerationStrategy(
            [NotNull] this IMutableProperty property, MySqlValueGenerationStrategy? value)
        {
            CheckValueGenerationStrategy(property, value);

            property.SetOrRemoveAnnotation(MySqlAnnotationNames.ValueGenerationStrategy, value);
        }

        private static void CheckValueGenerationStrategy(IProperty property, MySqlValueGenerationStrategy? value)
        {
            if (value != null)
            {
                var propertyType = property.ClrType;

                if (value == MySqlValueGenerationStrategy.IdentityColumn
                    && !IsCompatibleIdentityColumn(property))
                {
                    throw new ArgumentException(
                            MySqlStrings.IdentityBadType(
                                property.Name, property.DeclaringEntityType.DisplayName(), propertyType.ShortDisplayName()));
                }

                if (value == MySqlValueGenerationStrategy.ComputedColumn
                    && !IsCompatibleComputedColumn(property))
                {
                    throw new ArgumentException(
                            MySqlStrings.ComputedBadType(
                                property.Name, property.DeclaringEntityType.DisplayName(), propertyType.ShortDisplayName()));
                }
            }
        }

        /// <summary>
        ///     Returns a value indicating whether the property is compatible with <see cref="MySqlValueGenerationStrategy.IdentityColumn"/>.
        /// </summary>
        /// <param name="property"> The property. </param>
        /// <returns> <c>true</c> if compatible. </returns>
        public static bool IsCompatibleIdentityColumn(IProperty property)
        {
            var type = property.ClrType;

            return (type.IsInteger()
                        || type == typeof(decimal)
                        || type == typeof(DateTime)
                        || type == typeof(DateTimeOffset))
                   && !HasConverter(property);
        }

        /// <summary>
        ///     Returns a value indicating whether the property is compatible with <see cref="MySqlValueGenerationStrategy.ComputedColumn"/>.
        /// </summary>
        /// <param name="property"> The property. </param>
        /// <returns> <c>true</c> if compatible. </returns>
        public static bool IsCompatibleComputedColumn(IProperty property)
        {
            var type = property.ClrType;

            // RowVersion uses byte[] and the BytesToDateTimeConverter.
            return (type == typeof(DateTime) || type == typeof(DateTimeOffset)) && !HasConverter(property)
                   || type == typeof(byte[]) && !HasExternalConverter(property);
        }

        private static bool HasConverter(IProperty property)
            => GetConverter(property) != null;

    /// <summary>
    ///     <para>
    ///         Returns the <see cref="MySQLValueGenerationStrategy" /> to use for the property.
    ///     </para>
    ///     <para>
    ///         If no strategy is set for the property, then the strategy to use will be taken from the <see cref="IModel" />.
    ///     </para>
    /// </summary>
    /// <returns> The strategy, or <see cref="SqlServerValueGenerationStrategy.None" /> if none was set. </returns>
    public static MySQLValueGenerationStrategy? GetValueGenerationStrategy([NotNull] this IReadOnlyProperty property, StoreObjectIdentifier storeObject = default)
    {
      var annotation = property[MySQLAnnotationNames.ValueGenerationStrategy];
      if (annotation != null)
      {
        return (MySQLValueGenerationStrategy)annotation;
      }

      if (property.GetContainingForeignKeys().Any(fk => !fk.IsBaseLinking()) ||
          property.TryGetDefaultValue(storeObject, out _) ||
          property.GetDefaultValueSql() != null ||
          property.GetComputedColumnSql() != null)
      {
        return null;
      }

      if (storeObject != default &&
          property.ValueGenerated == ValueGenerated.Never )
      {
        return property.FindSharedStoreObjectRootProperty(storeObject)?.GetValueGenerationStrategy(storeObject);
      }

      if (IsCompatibleIdentityColumn(property) && property.ValueGenerated == ValueGenerated.OnAdd)
      {
        return MySQLValueGenerationStrategy.IdentityColumn;
      }

      if (IsCompatibleComputedColumn(property) && property.ValueGenerated == ValueGenerated.OnAddOrUpdate)
      {
        return MySQLValueGenerationStrategy.ComputedColumn;
      }

      return null;
    }


    /// <summary>
    /// Indicates whether the property is compatible with <see cref="MySQLValueGenerationStrategy.IdentityColumn"/>.
    /// </summary>
    /// <param name="property"> The property. </param>
    /// <returns><see langword="true"/> if compatible; otherwise, <see langword="false"/>.</returns>
    public static bool IsCompatibleIdentityColumn(IReadOnlyProperty property)
            => IsCompatibleAutoIncrementColumn(property) ||
               IsCompatibleCurrentTimestampColumn(property);

    /// <summary>
    ///     Returns a value indicating whether the property is compatible with an `AUTO_INCREMENT` column.
    /// </summary>
    /// <param name="property"> The property. </param>
    /// <returns> <see langword="true"/> if compatible. </returns>
    public static bool IsCompatibleAutoIncrementColumn(IReadOnlyProperty property)
    {
      var valueConverter = GetConverter(property);
      var type = (valueConverter?.ProviderClrType ?? property.ClrType).UnwrapNullableType();
      return type.IsInteger() ||
             type == typeof(decimal);
    }

    /// <summary>
    ///     Returns a value indicating whether the property is compatible with a `CURRENT_TIMESTAMP` column default.
    /// </summary>
    /// <param name="property"> The property. </param>
    /// <returns> <see langword="true"/> if compatible. </returns>
    public static bool IsCompatibleCurrentTimestampColumn(IReadOnlyProperty property)
    {
      var valueConverter = GetConverter(property);
      var type = (valueConverter?.ProviderClrType ?? property.ClrType).UnwrapNullableType();
      return type == typeof(DateTime) ||
             type == typeof(DateTimeOffset);
    }

    /// <summary>
    /// Indicates whether the property is compatible with <see cref="MySQLValueGenerationStrategy.ComputedColumn"/>.
    /// </summary>
    /// <param name="property"> The property. </param>
    /// <returns><see langword="true"/> if compatible; otherwise, <see langword="false"/>.</returns>
    public static bool IsCompatibleComputedColumn(IReadOnlyProperty property)
    {
      var type = property.ClrType;

      // RowVersion uses byte[] and the BytesToDateTimeConverter.
      return (type == typeof(DateTime) || type == typeof(DateTimeOffset)) && !HasConverter(property)
             || type == typeof(byte[]) && !HasExternalConverter(property);
    }

    private static bool HasConverter(IReadOnlyProperty property)
    => GetConverter(property) != null;


    public virtual ResultSetMapping AppendBulkInsertOperation(
      StringBuilder commandStringBuilder,
      IReadOnlyList<ModificationCommand> modificationCommands,
      int commandPosition)
    {
      var table = StoreObjectIdentifier.Table(modificationCommands[0].TableName, modificationCommands[0].Schema);
      if (modificationCommands.Count == 1
          && modificationCommands[0].ColumnModifications.All(
                           o => !o.IsKey
                        || !o.IsRead
                        || o.Property?.GetValueGenerationStrategy(table) == MySQLValueGenerationStrategy.IdentityColumn))
      {
        return AppendInsertOperation(commandStringBuilder, modificationCommands[0], commandPosition);
      }

      var readOperations = modificationCommands[0].ColumnModifications.Where(o => o.IsRead).ToList();
      var writeOperations = modificationCommands[0].ColumnModifications.Where(o => o.IsWrite).ToList();
      var keyOperations = modificationCommands[0].ColumnModifications.Where(o => o.IsKey).ToList();

      var defaultValuesOnly = writeOperations.Count == 0;
      var nonIdentityOperations = modificationCommands[0].ColumnModifications
          .Where(o => o.Property?.GetValueGenerationStrategy(table) != MySQLValueGenerationStrategy.IdentityColumn)
          .ToList();

      if (defaultValuesOnly)
      {
        if (nonIdentityOperations.Count == 0 || readOperations.Count == 0)
        {
          foreach (var modification in modificationCommands)
          {
            AppendInsertOperation(commandStringBuilder, modification, commandPosition);
          }

          return readOperations.Count == 0
              ? ResultSetMapping.NoResultSet
              : ResultSetMapping.LastInResultSet;
        }

        if (nonIdentityOperations.Count > 1)
        {
          nonIdentityOperations = new List<IColumnModification> { nonIdentityOperations.First() };
        }
      }

      if (readOperations.Count == 0)
      {
        return AppendBulkInsertWithoutServerValues(commandStringBuilder, modificationCommands, writeOperations);
      }

      foreach (var modification in modificationCommands)
      {
        AppendInsertOperation(commandStringBuilder, modification, commandPosition);
      }

      return ResultSetMapping.LastInResultSet;
    }

    private ResultSetMapping AppendBulkInsertWithoutServerValues(
    StringBuilder commandStringBuilder,
    IReadOnlyList<ModificationCommand> modificationCommands,
    List<IColumnModification> writeOperations)
    {
      Debug.Assert(writeOperations.Count > 0);

      var name = modificationCommands[0].TableName;
      var schema = modificationCommands[0].Schema;

      AppendInsertCommandHeader(commandStringBuilder, name, schema, writeOperations);
      AppendValuesHeader(commandStringBuilder, writeOperations);
      AppendValues(commandStringBuilder,string.Empty, null, writeOperations);
      for (var i = 1; i < modificationCommands.Count; i++)
      {
        commandStringBuilder.Append(",").AppendLine();
        AppendValues(commandStringBuilder,string.Empty,null, modificationCommands[i].ColumnModifications.Where(o => o.IsWrite).ToList());
      }
      commandStringBuilder.Append(SqlGenerationHelper.StatementTerminator).AppendLine();

      return ResultSetMapping.NoResultSet;
    }

    protected override void AppendInsertCommandHeader(
                [NotNull] StringBuilder commandStringBuilder,
                [NotNull] string name,
                 string? schema,
                [NotNull] IReadOnlyList<IColumnModification> operations)
    {
      Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
      Check.NotEmpty(name, nameof(name));
      Check.NotNull(operations, nameof(operations));

      base.AppendInsertCommandHeader(commandStringBuilder, name, schema, operations);

      if (operations.Count <= 0)
      {
        commandStringBuilder.Append(" ()");
      }
    }

    protected override void AppendValuesHeader(
        [NotNull] StringBuilder commandStringBuilder,
        [NotNull] IReadOnlyList<IColumnModification> operations)
    {
      Check.NotNull(commandStringBuilder, nameof(commandStringBuilder));
      Check.NotNull(operations, nameof(operations));

      commandStringBuilder.AppendLine();
      commandStringBuilder.Append("VALUES ");
    }

    protected override void AppendValues(
                [NotNull] StringBuilder commandStringBuilder,
                [NotNull] string name,
                  string? schema,
                [NotNull] IReadOnlyList<IColumnModification> operations)
    {
      base.AppendValues(commandStringBuilder, name, schema, operations);

      if (operations.Count <= 0)
      {
        commandStringBuilder.Append("()");
      }
    }

    protected override void AppendIdentityWhereCondition(StringBuilder commandStringBuilder, IColumnModification columnModification)
    {
      Check.NotNull(columnModification, "columnModification");
      Check.NotNull(commandStringBuilder, "commandStringBuilder");
      commandStringBuilder.AppendFormat("{0}=LAST_INSERT_ID()", SqlGenerationHelper.DelimitIdentifier(columnModification.ColumnName));
    }

        /// <summary>
        ///     <para>
        ///         Returns the <see cref="MySqlValueGenerationStrategy" /> to use for the property.
        ///     </para>
        ///     <para>
        ///         If no strategy is set for the property, then the strategy to use will be taken from the <see cref="IModel" />.
        ///     </para>
        /// </summary>
        /// <returns> The strategy, or <see cref="MySqlValueGenerationStrategy.None"/> if none was set. </returns>
        public static MySqlValueGenerationStrategy? GetValueGenerationStrategy([NotNull] this IReadOnlyProperty property, StoreObjectIdentifier storeObject = default)
        {
            var annotation = property[MySqlAnnotationNames.ValueGenerationStrategy];
            if (annotation != null)
            {
                // Allow users to use the underlying type value instead of the enum itself.
                // Workaround for: https://github.com/PomeloFoundation/Pomelo.EntityFrameworkCore.MySql/issues/1205
                //return ObjectToEnumConverter.GetEnumValue<MySqlValueGenerationStrategy>(annotation);
                return ObjectToEnumConverter.GetEnumValue<MySqlValueGenerationStrategy>(annotation);
            }

            if (property.GetContainingForeignKeys().Any(fk => !fk.IsBaseLinking()) ||
                property.TryGetDefaultValue(storeObject, out _) ||
                property.GetDefaultValueSql() != null ||
                property.GetComputedColumnSql() != null)
            {
                return null;
            }

            if (storeObject != default &&
                property.ValueGenerated == ValueGenerated.Never)
            {
                return property.FindSharedStoreObjectRootProperty(storeObject)
                    ?.GetValueGenerationStrategy(storeObject);
            }

            if (property.ValueGenerated == ValueGenerated.OnAdd &&
                IsCompatibleIdentityColumn(property))
            {
                return MySqlValueGenerationStrategy.IdentityColumn;
            }

            if (property.ValueGenerated == ValueGenerated.OnAddOrUpdate &&
                IsCompatibleComputedColumn(property))
            {
                return MySqlValueGenerationStrategy.ComputedColumn;
            }

            return null;
        }

        /// <summary>
        ///     Sets the <see cref="MySqlValueGenerationStrategy" /> to use for the property.
        /// </summary>
        /// <param name="property"> The property. </param>
        /// <param name="value"> The strategy to use. </param>
        public static void SetValueGenerationStrategy(
            [NotNull] this IMutableProperty property, MySqlValueGenerationStrategy? value)
        {
            CheckValueGenerationStrategy(property, value);

            property.SetOrRemoveAnnotation(MySqlAnnotationNames.ValueGenerationStrategy, value);
        }

        /// <summary>
        ///     Sets the <see cref="MySqlValueGenerationStrategy" /> to use for the property.
        /// </summary>
        /// <param name="property"> The property. </param>
        /// <param name="value"> The strategy to use. </param>
        /// <param name="fromDataAnnotation">Indicates whether the configuration was specified using a data annotation.</param>
        public static MySqlValueGenerationStrategy? SetValueGenerationStrategy([NotNull] this IConventionProperty property, MySqlValueGenerationStrategy? value, bool fromDataAnnotation = false)
        {
            CheckValueGenerationStrategy(property, value);

            property.SetOrRemoveAnnotation(MySqlAnnotationNames.ValueGenerationStrategy, value, fromDataAnnotation);

            return value;
        }

        /// <summary>
        /// Returns the <see cref="ConfigurationSource" /> for the <see cref="MySqlValueGenerationStrategy" />.
        /// </summary>
        /// <param name="property">The property.</param>
        /// <returns>The <see cref="ConfigurationSource" /> for the <see cref="MySqlValueGenerationStrategy" />.</returns>
        public static ConfigurationSource? GetValueGenerationStrategyConfigurationSource(this IConventionProperty property)
            => property.FindAnnotation(MySqlAnnotationNames.ValueGenerationStrategy)?.GetConfigurationSource();

        private static void CheckValueGenerationStrategy(IReadOnlyProperty property, MySqlValueGenerationStrategy? value)
        {
            if (value != null)
            {
                var propertyType = property.ClrType;

                if (value == MySqlValueGenerationStrategy.IdentityColumn
                    && !IsCompatibleIdentityColumn(property))
                {
                    throw new ArgumentException(
                            MySqlStrings.IdentityBadType(
                                property.Name, property.DeclaringEntityType.DisplayName(), propertyType.ShortDisplayName()));
                }

                if (value == MySqlValueGenerationStrategy.ComputedColumn
                    && !IsCompatibleComputedColumn(property))
                {
                    throw new ArgumentException(
                            MySqlStrings.ComputedBadType(
                                property.Name, property.DeclaringEntityType.DisplayName(), propertyType.ShortDisplayName()));
                }
            }
        }

        /// <summary>
        ///     Returns a value indicating whether the property is compatible with <see cref="MySqlValueGenerationStrategy.IdentityColumn"/>.
        /// </summary>
        /// <param name="property"> The property. </param>
        /// <returns> <see langword="true"/> if compatible. </returns>
        public static bool IsCompatibleIdentityColumn(IReadOnlyProperty property)
            => IsCompatibleAutoIncrementColumn(property) ||
               IsCompatibleCurrentTimestampColumn(property);


        public override IEnumerable<IAnnotation> For(IRelationalModel model, bool designTime)
        {
            if (!designTime)
            {
                yield break;
            }

            if (GetActualModelCharSet(model.Model, DelegationModes.ApplyToDatabases) is string charSet)
            {
                yield return new Annotation(
                    MySqlAnnotationNames.CharSet,
                    charSet);
            }

            // If a collation delegation modes has been set, but does not contain DelegationModes.ApplyToDatabase, we reset the EF Core
            // handled Collation property in MySqlMigrationsModelDiffer.

            // Handle other annotations (including the delegation annotations).
            foreach (var annotation in model.Model.GetAnnotations()
                .Where(a => a.Name is MySqlAnnotationNames.CharSetDelegation or
                                      MySqlAnnotationNames.CollationDelegation))
            {
                yield return annotation;
            }
        }

        public override IEnumerable<IAnnotation> For(ITable table, bool designTime)
        {
            if (!designTime)
            {
                yield break;
            }

            // Model validation ensures that these facets are the same on all mapped entity types
            var entityType = table.EntityTypeMappings.First().EntityType;

            // Use an explicitly defined character set, if set.
            // Otherwise, explicitly use the model/database character set, if delegation is enabled.
            if (GetActualEntityTypeCharSet(entityType, DelegationModes.ApplyToTables) is string charSet)
            {
                yield return new Annotation(
                    MySqlAnnotationNames.CharSet,
                    charSet);
            }

            // Use an explicitly defined collation, if set.
            // Otherwise, explicitly use the model/database collation, if delegation is enabled.
            if (GetActualEntityTypeCollation(entityType, DelegationModes.ApplyToTables) is string collation)
            {
                yield return new Annotation(
                    RelationalAnnotationNames.Collation,
                    collation);
            }

            // Handle other annotations (including the delegation annotations).
            foreach (var annotation in entityType.GetAnnotations()
                .Where(a => a.Name is MySqlAnnotationNames.CharSetDelegation or
                                      MySqlAnnotationNames.CollationDelegation or
                                      MySqlAnnotationNames.StoreOptions))
            {
                yield return annotation;
            }
        }

        public override IEnumerable<IAnnotation> For(IUniqueConstraint constraint, bool designTime)
        {
            if (!designTime)
            {
                yield break;
            }

            // Model validation ensures that these facets are the same on all mapped indexes
            var key = constraint.MappedKeys.First();

            var prefixLength = key.PrefixLength();
            if (prefixLength != null &&
                prefixLength.Length > 0)
            {
                yield return new Annotation(
                    MySqlAnnotationNames.IndexPrefixLength,
                    prefixLength);
            }
        }

        public override IEnumerable<IAnnotation> For(ITableIndex index, bool designTime)
        {
            if (!designTime)
            {
                yield break;
            }

            // Model validation ensures that these facets are the same on all mapped indexes
            var modelIndex = index.MappedIndexes.First();

            var prefixLength = modelIndex.PrefixLength();
            if (prefixLength != null &&
                prefixLength.Length > 0)
            {
                yield return new Annotation(
                    MySqlAnnotationNames.IndexPrefixLength,
                    prefixLength);
            }

            var isFullText = modelIndex.IsFullText();
            if (isFullText.HasValue)
            {
                yield return new Annotation(
                    MySqlAnnotationNames.FullTextIndex,
                    isFullText.Value);
            }

            var fullTextParser = modelIndex.FullTextParser();
            if (!string.IsNullOrEmpty(fullTextParser))
            {
                yield return new Annotation(
                    MySqlAnnotationNames.FullTextParser,
                    fullTextParser);
            }

            var isSpatial = modelIndex.IsSpatial();
            if (isSpatial.HasValue)
            {
                yield return new Annotation(
                    MySqlAnnotationNames.SpatialIndex,
                    isSpatial.Value);
            }
        }

        public override IEnumerable<IAnnotation> For(IColumn column, bool designTime)
        {
            if (!designTime)
            {
                yield break;
            }

            var table = StoreObjectIdentifier.Table(column.Table.Name, column.Table.Schema);
            var properties = column.PropertyMappings.Select(m => m.Property).ToArray();

            if (column.PropertyMappings.Where(
                    m => m.TableMapping.IsSharedTablePrincipal &&
                         m.TableMapping.EntityType == m.Property.DeclaringEntityType)
                .Select(m => m.Property)
                .FirstOrDefault(p => p.GetValueGenerationStrategy(table) == MySqlValueGenerationStrategy.IdentityColumn) is IProperty identityProperty)
            {
                var valueGenerationStrategy = identityProperty.GetValueGenerationStrategy(table);
                yield return new Annotation(
                    MySqlAnnotationNames.ValueGenerationStrategy,
                    valueGenerationStrategy);
            }
            else if (properties.FirstOrDefault(
                p => p.GetValueGenerationStrategy(table) == MySqlValueGenerationStrategy.ComputedColumn) is IProperty computedProperty)
            {
                var valueGenerationStrategy = computedProperty.GetValueGenerationStrategy(table);
                yield return new Annotation(
                    MySqlAnnotationNames.ValueGenerationStrategy,
                    valueGenerationStrategy);
            }

            // Use an explicitly defined character set, if set.
            // Otherwise, explicitly use the entity/table or model/database character set, if delegation is enabled.
            if (GetActualPropertyCharSet(properties, DelegationModes.ApplyToColumns) is string charSet)
            {
                yield return new Annotation(
                    MySqlAnnotationNames.CharSet,
                    charSet);
            }

            // Use an explicitly defined collation, if set.
            // Otherwise, explicitly use the entity/table or model/database collation, if delegation is enabled.
            if (GetActualPropertyCollation(properties, DelegationModes.ApplyToColumns) is string collation)
            {
                yield return new Annotation(
                    RelationalAnnotationNames.Collation,
                    collation);
            }

            if (column.PropertyMappings.Select(m => m.Property.GetSpatialReferenceSystem())
                .FirstOrDefault(c => c != null) is int srid)
            {
                yield return new Annotation(
                    MySqlAnnotationNames.SpatialReferenceSystemId,
                    srid);
            }
        }

        protected virtual string GetActualModelCharSet(IModel model, DelegationModes currentLevel)
        {
            // If neither character set nor collation has been explicitly defined for the model, and no delegation has been setup, we use
            // Pomelo's universal fallback default character set (which is `utf8mb4`) and apply it to all database objects.
            return model.GetCharSet() is null &&
                   model.GetCharSetDelegation() is null &&
                   model.GetCollation() is null &&
                   model.GetCollationDelegation() is null
                ? _options.DefaultCharSet.Name
                : model.GetActualCharSetDelegation().HasFlag(currentLevel)
                    ? model.GetCharSet()
                    : null;
        }

MySql.Data.EntityFrameworkCore.Extensions.MySQLPropertyExtensions : Object

Methods :

public static Nullable<MySQLValueGenerationStrategy> GetValueGenerationStrategy(IProperty property = )
public static Boolean IsCompatibleIdentityColumn(IProperty property = )
public static Boolean IsCompatibleComputedColumn(IProperty property = )
public Type GetType()
public String ToString()
public Boolean Equals(Object obj = )
public Int32 GetHashCode()