public RelationalEntityTypeBuilderAnnotations(
     [NotNull] InternalEntityTypeBuilder internalBuilder,
     ConfigurationSource configurationSource,
     [CanBeNull] string providerPrefix)
     : base(new RelationalAnnotationsBuilder(internalBuilder, configurationSource, providerPrefix))
 {
 }

 internal override ConfigurationSource BuildUpConfiguration(ConfigurationSource previousSource)
 {
     this.Populate(previousSource);
     this.FindSubscribers();
     this.FindMessageFilters();
     return this;
 }

        public virtual bool Annotation(
            [NotNull] string annotation, [CanBeNull] object value, ConfigurationSource configurationSource)
        {
            var existingValue = Metadata[annotation];
            if (existingValue != null)
            {
                ConfigurationSource existingConfigurationSource;
                if (!_annotationSources.Value.TryGetValue(annotation, out existingConfigurationSource))
                {
                    existingConfigurationSource = ConfigurationSource.Explicit;
                }

                if ((value == null || existingValue != value)
                    && !configurationSource.Overrides(existingConfigurationSource))
                {
                    return false;
                }

                configurationSource = configurationSource.Max(existingConfigurationSource);
            }

            if (value != null)
            {
                _annotationSources.Value[annotation] = configurationSource;
                Metadata[annotation] = value;
            }
            else
            {
                _annotationSources.Value.Remove(annotation);
                Metadata.RemoveAnnotation(new Annotation(annotation, "_"));
            }

            return true;
        }

        /// <summary>
        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used 
        ///     directly from your code. This API may change or be removed in future releases.
        /// </summary>
        public ForeignKey(
            [NotNull] IReadOnlyList<Property> dependentProperties,
            [NotNull] Key principalKey,
            [NotNull] EntityType dependentEntityType,
            [NotNull] EntityType principalEntityType,
            ConfigurationSource configurationSource)
        {
            Check.NotEmpty(dependentProperties, nameof(dependentProperties));
            Check.HasNoNulls(dependentProperties, nameof(dependentProperties));
            Check.NotNull(principalKey, nameof(principalKey));
            Check.NotNull(principalEntityType, nameof(principalEntityType));

            Properties = dependentProperties;
            PrincipalKey = principalKey;
            DeclaringEntityType = dependentEntityType;
            PrincipalEntityType = principalEntityType;
            _configurationSource = configurationSource;

            AreCompatible(principalKey.Properties, dependentProperties, principalEntityType, dependentEntityType, shouldThrow: true);

            if (!principalEntityType.GetKeys().Contains(principalKey))
            {
                throw new InvalidOperationException(
                    CoreStrings.ForeignKeyReferencedEntityKeyMismatch(
                        Property.Format(principalKey.Properties),
                        principalEntityType));
            }

            Builder = new InternalRelationshipBuilder(this, dependentEntityType.Model.Builder);
        }

        private bool Annotation(
            string annotation, object value, ConfigurationSource configurationSource, bool canOverrideSameSource)
        {
            var existingValue = Metadata[annotation];
            if (existingValue != null)
            {
                ConfigurationSource existingConfigurationSource;
                if (!_annotationSources.Value.TryGetValue(annotation, out existingConfigurationSource))
                {
                    existingConfigurationSource = ConfigurationSource.Explicit;
                }

                if ((value == null || !existingValue.Equals(value))
                    && (!configurationSource.Overrides(existingConfigurationSource)
                    || configurationSource == existingConfigurationSource && !canOverrideSameSource))
                {
                    return false;
                }

                configurationSource = configurationSource.Max(existingConfigurationSource);
            }

            if (value != null)
            {
                _annotationSources.Value[annotation] = configurationSource;
                Metadata[annotation] = value;
            }
            else
            {
                _annotationSources.Value.Remove(annotation);
                Metadata.RemoveAnnotation(new Annotation(annotation, "_"));
            }

            return true;
        }

 public RelationalForeignKeyBuilderAnnotations(
     [NotNull] InternalRelationshipBuilder internalBuilder,
     ConfigurationSource configurationSource,
     [CanBeNull] string providerPrefix)
     : base(new RelationalAnnotationsBuilder(internalBuilder, configurationSource, providerPrefix))
 {
 }

        public static bool Overrides(this ConfigurationSource newConfigurationSource, ConfigurationSource? oldConfigurationSource)
        {
            if (oldConfigurationSource == null)
            {
                return true;
            }

            if (newConfigurationSource == ConfigurationSource.Explicit)
            {
                return true;
            }

            if (oldConfigurationSource == ConfigurationSource.Explicit)
            {
                return false;
            }

            if (newConfigurationSource == ConfigurationSource.DataAnnotation)
            {
                return true;
            }

            if (oldConfigurationSource == ConfigurationSource.DataAnnotation)
            {
                return false;
            }

            return true;
        }

 public RelationalEntityTypeBuilderAnnotations(
     [NotNull] InternalEntityTypeBuilder internalBuilder,
     ConfigurationSource configurationSource,
     [CanBeNull] RelationalFullAnnotationNames providerFullAnnotationNames)
     : base(new RelationalAnnotationsBuilder(internalBuilder, configurationSource), providerFullAnnotationNames)
 {
 }

        /// <summary>
        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used 
        ///     directly from your code. This API may change or be removed in future releases.
        /// </summary>
        public RelationalAnnotationsBuilder(
            [NotNull] InternalMetadataBuilder internalBuilder,
            ConfigurationSource configurationSource)
            : base(internalBuilder.Metadata)
        {
            Check.NotNull(internalBuilder, nameof(internalBuilder));

            MetadataBuilder = internalBuilder;
            ConfigurationSource = configurationSource;
        }

        /// <summary>
        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used 
        ///     directly from your code. This API may change or be removed in future releases.
        /// </summary>
        public virtual bool CanSetAnnotation([NotNull] string name, [CanBeNull] object value, ConfigurationSource configurationSource)
        {
            var existingAnnotation = Metadata.FindAnnotation(name);
            if (existingAnnotation != null)
            {
                return CanSetAnnotationValue(existingAnnotation, value, configurationSource, canOverrideSameSource: true);
            }

            return true;
        }

        public static ConfigurationSource Max(this ConfigurationSource left, ConfigurationSource? right)
        {
            if (!right.HasValue
                || left.Overrides(right.Value))
            {
                return left;
            }

            return right.Value;
        }

        public RelationalAnnotationsBuilder(
            [NotNull] InternalMetadataBuilder internalBuilder,
            ConfigurationSource configurationSource,
            [CanBeNull] string providerPrefix)
            : base(internalBuilder.Metadata, providerPrefix)
        {
            Check.NotNull(internalBuilder, nameof(internalBuilder));

            EntityTypeBuilder = internalBuilder;
            ConfigurationSource = configurationSource;
        }

        /// <summary>
        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used 
        ///     directly from your code. This API may change or be removed in future releases.
        /// </summary>
        public virtual EntityType AddEntityType(
            [NotNull] string name,
            // ReSharper disable once MethodOverloadWithOptionalParameter
            ConfigurationSource configurationSource = ConfigurationSource.Explicit,
            bool runConventions = true)
        {
            Check.NotEmpty(name, nameof(name));

            var entityType = new EntityType(name, this, configurationSource);

            return AddEntityType(entityType, runConventions);
        }

        /// <summary>
        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used 
        ///     directly from your code. This API may change or be removed in future releases.
        /// </summary>
        public Property(
            [NotNull] PropertyInfo propertyInfo,
            [NotNull] EntityType declaringEntityType,
            ConfigurationSource configurationSource)
            : base(Check.NotNull(propertyInfo, nameof(propertyInfo)).Name, propertyInfo)
        {
            Check.NotNull(declaringEntityType, nameof(declaringEntityType));

            DeclaringEntityType = declaringEntityType;
            ClrType = propertyInfo.PropertyType;
            Initialize(declaringEntityType, configurationSource);
        }

        private static Dictionary<string, string> CombineParameters(ConfigurationSource source, string resource, Dictionary<string, string> parameters) {
            if (source == ConfigurationSource.Xml || resource.IndexOf('?') <= 0)
                return parameters;

            if (parameters == null) {
                parameters = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            }
            foreach (var pair in Common.ParseQueryString(resource.Substring(resource.IndexOf('?')))) {
                parameters[pair.Key] = pair.Value;
            }
            return parameters;
        }

        private EntityType AddEntityTypeWithoutConventions(string name, ConfigurationSource configurationSource)
        {
            var entityType = new MaterializingEntityType(name, this, configurationSource);
            var previousLength = _entityTypes.Count;
            _entityTypes[name] = entityType;

            if (previousLength == _entityTypes.Count)
            {
                throw new InvalidOperationException(CoreStrings.DuplicateEntityType(entityType.Name));
            }
            return entityType;
        }

        public static bool CanSet(this ConfigurationSource newConfigurationSource, ConfigurationSource? oldConfigurationSource, bool isValueSet)
        {
            if (isValueSet)
            {
                var existingConfigurationSource = oldConfigurationSource ?? ConfigurationSource.Explicit;

                if (!newConfigurationSource.Overrides(existingConfigurationSource))
                {
                    return false;
                }
            }

            return true;
        }

        public Index(
            [NotNull] IReadOnlyList<Property> properties,
            [NotNull] EntityType declaringEntityType,
            ConfigurationSource configurationSource)
        {
            Check.NotEmpty(properties, nameof(properties));
            Check.HasNoNulls(properties, nameof(properties));
            Check.NotNull(declaringEntityType, nameof(declaringEntityType));

            Properties = properties;
            DeclaringEntityType = declaringEntityType;
            _configurationSource = configurationSource;

            Builder = new InternalIndexBuilder(this, declaringEntityType.Model.Builder);
        }

        private bool HasAnnotation(
            string name, object value, ConfigurationSource configurationSource, bool canOverrideSameSource)
        {
            var existingAnnotation = Metadata.FindAnnotation(name);
            if (existingAnnotation != null)
            {
                if (existingAnnotation.Value.Equals(value))
                {
                    existingAnnotation.UpdateConfigurationSource(configurationSource);
                    return true;
                }

                var existingConfigurationSource = existingAnnotation.GetConfigurationSource();
                if (!configurationSource.Overrides(existingConfigurationSource)
                    || (configurationSource == existingConfigurationSource && !canOverrideSameSource))
                {
                    return false;
                }

                if (value == null)
                {
                    var removed = Metadata.RemoveAnnotation(name);
                    Debug.Assert(removed == existingAnnotation);
                }
                else
                {
                    Metadata.SetAnnotation(name, value, configurationSource);
                }

                return true;
            }

            if (value != null)
            {
                Metadata.AddAnnotation(name, value, configurationSource);
            }

            return true;
        }

 public MaterializingEntityType(string name, Model model, ConfigurationSource configurationSource) : base(name, model, configurationSource)
 {
 }