internal static DbSpatialServices GetSpatialServices(IDbDependencyResolver resolver, EntityConnection connection) { DebugCheck.NotNull(resolver); DebugCheck.NotNull(connection); var storeItemCollection = (StoreItemCollection)connection.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace); var key = new DbProviderInfo( storeItemCollection.ProviderInvariantName, storeItemCollection.ProviderManifestToken); return(GetSpatialServices(resolver, key, () => GetProviderServices(connection.StoreConnection))); }
public void SetSpatialProvider_with_key_delegates_to_internal_configuration() { var mockInternalConfiguration = new Mock <InternalConfiguration>(null, null, null, null); var provider = SqlSpatialServices.Instance; var key = new DbProviderInfo("A.Little.Time", "Paul"); new DbConfiguration(mockInternalConfiguration.Object).AddDbSpatialServices(key, provider); mockInternalConfiguration.Verify(m => m.RegisterSingleton <DbSpatialServices>(provider, key)); }
/// <inheritdoc /> public virtual void Apply(ComplexType item, DbModel model) { Check.NotNull <ComplexType>(item, nameof(item)); Check.NotNull <DbModel>(model, nameof(model)); DbProviderInfo providerInfo = model.ProviderInfo; if (providerInfo == null || !providerInfo.IsSqlCe()) { return; } this.SetLength((IEnumerable <EdmProperty>)item.Properties); }
public static StoreItemCollection GetStoreItemCollection(this XDocument model, out DbProviderInfo providerInfo) { DebugCheck.NotNull(model); var schemaElement = model.Descendants(EdmXNames.Ssdl.SchemaNames).Single(); providerInfo = new DbProviderInfo( schemaElement.ProviderAttribute(), schemaElement.ProviderManifestTokenAttribute()); return(new StoreItemCollection(new[] { schemaElement.CreateReader() })); }
public void GetSpatialServices_uses_resolver_to_obtain_provider_specific_spatial_services() { var mockSpatialServices = new Mock <DbSpatialServices>(); var mockResolver = new Mock <IDbDependencyResolver>(); var key = new DbProviderInfo("Pefect.Day", "Lou"); mockResolver.Setup(m => m.GetService(typeof(DbSpatialServices), key)).Returns(mockSpatialServices.Object); Assert.Same( mockSpatialServices.Object, new Mock <DbProviderServices>((Func <IDbDependencyResolver>)(() => mockResolver.Object)).Object.GetSpatialServices(key)); }
/// <summary> /// Builds and stores the workspace based on the given code first configuration. /// </summary> /// <param name="databaseMapping"> The code first EDM model. </param> public CodeFirstCachedMetadataWorkspace(DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); _providerInfo = databaseMapping.ProviderInfo; _metadataWorkspace = databaseMapping.ToMetadataWorkspace(); _assemblies = databaseMapping.Model.GetClrTypes().Select(t => t.Assembly).Distinct().ToList(); Debug.Assert(databaseMapping.Model.Containers.Count() == 1, "Expecting Code First to create only one container."); _defaultContainerName = databaseMapping.Model.Containers.First().Name; }
private static DbSpatialServices GetSpatialServices( IDbDependencyResolver resolver, DbProviderInfo key, Func <DbProviderServices> providerServices) { DbSpatialServices orAdd = DbProviderServices._spatialServices.GetOrAdd(key, (Func <DbProviderInfo, DbSpatialServices>)(k => resolver.GetService <DbSpatialServices>((object)k) ?? providerServices().GetSpatialServices(k.ProviderManifestToken) ?? resolver.GetService <DbSpatialServices>())); if (orAdd == null) { throw new ProviderIncompatibleException(Strings.ProviderDidNotReturnSpatialServices); } return(orAdd); }
public static CodeFirstCachedMetadataWorkspace Create( StorageMappingItemCollection mappingItemCollection, DbProviderInfo providerInfo) { var conceptualModel = mappingItemCollection.EdmItemCollection; var entityClrTypes = conceptualModel.GetItems <EntityType>().Select(et => et.GetClrType()); var complexClrTypes = conceptualModel.GetItems <ComplexType>().Select(ct => ct.GetClrType()); return(new CodeFirstCachedMetadataWorkspace( mappingItemCollection.Workspace, entityClrTypes.Union(complexClrTypes).Select(t => t.Assembly()).Distinct().ToArray(), providerInfo, conceptualModel.GetItems <EntityContainer>().Single().Name)); }
static DbCompiledModel CreateModel() { var builder = new DbModelBuilder(); builder.Conventions.Remove <PluralizingTableNameConvention>(); builder.Entity <Language>().HasKey(m => m.Name); builder.Entity <EntityTranslationDbEntry>(); var providerInfo = new DbProviderInfo(SqlCeProviderServices.ProviderInvariantName, "4.0"); return(builder.Build(providerInfo).Compile()); }
internal static EdmModel CreateStoreModel( DbProviderInfo providerInfo, DbProviderManifest providerManifest, double schemaVersion = XmlConstants.SchemaVersionLatest) { DebugCheck.NotNull(providerInfo); DebugCheck.NotNull(providerManifest); return (new EdmModel(DataSpace.SSpace, schemaVersion) { ProviderInfo = providerInfo, ProviderManifest = providerManifest }); }
private void OnProviderChange() { DbProviderInfo dbProvider = dbProvidersComboBox.SelectedItem as DbProviderInfo; if (dbProvider != null) { fullTextCheckBox.Enabled = dbProvider.InvariantName == "System.Data.SqlClient"; if (dbProvider.InvariantName != "System.Data.SqlClient") { fullTextCheckBox.Checked = false; } Settings.Default.ProviderName = dbProvider.Name; } }
public static DbProviderInfo GetProviderInfo( this DbConnection connection, out DbProviderManifest providerManifest) { DebugCheck.NotNull(connection); var providerManifestToken = DbConfiguration .GetService <IManifestTokenService>() .GetProviderManifestToken(connection); var providerInfo = new DbProviderInfo(connection.GetProviderInvariantName(), providerManifestToken); providerManifest = DbProviderServices.GetProviderServices(connection).GetProviderManifest(providerManifestToken); return(providerInfo); }
static void Main(string[] args) { var mb = new DbModelBuilder(); mb.RegisterEntityType(typeof(Foo)); var pinfo = new DbProviderInfo("System.Data.SqlClient", "2008"); var ctx = new DbContext("Server=.;Database=Flange;Integrated Security=SSPI;", mb.Build(pinfo).Compile()); ctx.Set <Foo>().Add(new Foo { ID = 1 }); ctx.SaveChanges(); Console.ReadKey(); }
private void UpdateConnectionString() { if (_isConnectionStringUpdating) { return; } using (new DisposableToken <ConnectionStringBuilder>(this, x => x.Instance._isConnectionStringUpdating = true, x => x.Instance._isConnectionStringUpdating = false)) { var providerName = DatabaseProvider; var connectionString = ConnectionString; var providers = DbProvider.GetRegisteredProviders(); DbConnectionString displayedConnectionsString = null; DbProvider dbProvider = null; if (string.IsNullOrEmpty(providerName)) { foreach (var providerKeyValue in providers) { var currentProvider = providerKeyValue.Value; try { displayedConnectionsString = currentProvider.CreateConnectionString(connectionString); } catch { continue; } dbProvider = currentProvider; break; } } else { if (providers.TryGetValue(providerName, out dbProvider)) { displayedConnectionsString = dbProvider.CreateConnectionString(connectionString); } } _connectionStringTextBox.SetCurrentValue(TextBox.TextProperty, displayedConnectionsString?.ToDisplayString()); SetCurrentValue(DatabaseProviderProperty, dbProvider?.ProviderInvariantName); _dbProvider = dbProvider?.Info; } }
internal static CommerceDbContext Create(CommerceInstanceSettings metadata, ICommerceDbProvider dbProvider) { var dbProviderInfo = new DbProviderInfo(metadata.DbProviderInvariantName, metadata.DbProviderManifestToken); var model = _modelCache.GetOrAdd(new ModelCacheKey(metadata.DbSchema, dbProviderInfo), key => { return(CreateModel(key.Schema, key.DbProviderInfo)); }); var dbProviderFactory = DbConfiguration.DependencyResolver.GetService(typeof(DbProviderFactory), dbProvider.InvariantName) as DbProviderFactory; var conn = dbProviderFactory.CreateConnection(); conn.ConnectionString = dbProvider.GetConnectionString(metadata); return(new CommerceDbContext(metadata, conn, model)); }
private DbModel Build(DbProviderManifest providerManifest, DbProviderInfo providerInfo) { DebugCheck.NotNull(providerManifest); DebugCheck.NotNull(providerInfo); var schemaVersion = _modelBuilderVersion.GetEdmVersion(); var modelBuilderClone = Clone(); var model = new DbModel( new DbDatabaseMapping() { Model = EdmModel.CreateConceptualModel(schemaVersion), Database = EdmModel.CreateStoreModel(providerInfo, providerManifest, schemaVersion) }, modelBuilderClone); model.ConceptualModel.Container.AddAnnotation(XmlConstants.UseClrTypesAnnotationWithPrefix, "true"); _conventionsConfiguration.ApplyModelConfiguration(_modelConfiguration); _modelConfiguration.NormalizeConfigurations(); MapTypes(model.ConceptualModel); _modelConfiguration.Configure(model.ConceptualModel); _conventionsConfiguration.ApplyConceptualModel(model); model.ConceptualModel.Validate(); model = new DbModel( model.ConceptualModel.GenerateDatabaseMapping(providerInfo, providerManifest), modelBuilderClone); // Run the PluralizingTableNameConvention first so that the new table name is available for configuration _conventionsConfiguration.ApplyPluralizingTableNameConvention(model); _modelConfiguration.Configure(model.DatabaseMapping, providerManifest); _conventionsConfiguration.ApplyStoreModel(model); _conventionsConfiguration.ApplyMapping(model.DatabaseMapping); model.StoreModel.Validate(); return(model); }
static DbCompiledModel CreateModel(string schema, DbProviderInfo dbProviderInfo) { var builder = new DbModelBuilder(); if (!String.IsNullOrEmpty(schema)) { builder.HasDefaultSchema(schema); } builder.Conventions.Remove <PluralizingTableNameConvention>(); builder.Conventions.Add <NonPublicPropertyConvention>(); builder.Configurations.AddFromAssembly(Assembly.Load("Kooboo.Commerce.Infrastructure")); builder.Configurations.AddFromAssembly(Assembly.Load("Kooboo.Commerce")); return(builder.Build(dbProviderInfo).Compile()); }
private DbCompiledModel GetDbCompiledModel(ShellSettings shellSettings) { if (DbCompiledModelCacheDictionary.ContainsKey(shellSettings.Name)) { return(DbCompiledModelCacheDictionary[shellSettings.Name]); } var records = _recordBlueprints.ToArray(); var modelBuilder = new DbModelBuilder(); //设置数据库架构名称。 // modelBuilder.HasDefaultSchema(shellSettings.Name); //将记录类型添加至DbContext。 foreach (var recordBlueprint in records) { Entity(recordBlueprint.Type, modelBuilder); } //默认配置信息。 modelBuilder.Types().Configure(config => { var record = records.FirstOrDefault(i => i.Type == config.ClrType); if (record == null) { return; } config.ToTable(record.TableName); }); //应用约定。 modelBuilder.Conventions.Add(GetConventions()); var dataServiceProvider = GetDataServicesProvider(shellSettings); var connectionString = shellSettings.GetDataConnectionString(); string providerManifestToken; using (var connection = dataServiceProvider.CreateConnection(connectionString)) providerManifestToken = dataServiceProvider.Instance.GetProviderManifestToken(connection); var dbProviderInfo = new DbProviderInfo(dataServiceProvider.ProviderInvariantName, providerManifestToken); var dbModel = modelBuilder.Build(dbProviderInfo); return(dbModel.Compile()); }
public void UpdateStorageModel_add_errors_if_validation_fails() { var edmx = XDocument.Parse(EdmxTemplate); var storeModel = new EdmModel(DataSpace.SSpace); var providerInfo = new DbProviderInfo("ProviderInvariantName", "20081"); storeModel.AddItem( EntityType.Create("entities", "ns", DataSpace.SSpace, new string[0], new EdmMember[0], null)); var errors = new List <EdmSchemaError>(); new EdmxHelper(edmx) .UpdateStorageModels(storeModel, "myNamespace", providerInfo, errors); Assert.NotEmpty(errors); }
/// <summary> /// 实例化当前数据驱动 /// </summary> /// <param name="type">驱动类型名</param> /// <returns>当前的驱动</returns> public static IDbProvider Instance(ModelType type) { DbProviderInfo providerInfo = ModelConfig.GetDbProvider(type); string typename = providerInfo.Provider; IDbProvider provider = AppCtx.Cache.RetrieveObject <IDbProvider>(typename); if (provider == null) { string[] s = typename.Split(','); provider = Utils.CreateInstance <IDbProvider>(s[0], s[1]); if (provider == null) { throw new SystemException("不存在当前数据驱动:" + typename); } if (provider is CompositeProvider) { CompositeProvider cmp = provider as CompositeProvider; foreach (NameType item in providerInfo.Items) { if (String.Compare("singletable", item.Name, true) == 0 && !GeneralConfigs.GetConfig().EnableSingleTable) { continue; } IDbProvider subProvider = AppCtx.Cache.RetrieveObject <IDbProvider>(item.Type); if (subProvider == null) { subProvider = Utils.CreateInstance <IDbProvider>(item.Type); if (subProvider != null) { AppCtx.Cache.AddObjectWithFileChange(item.Type, subProvider, ModelConfig.ConfigFilePath, GeneralConfigs.ConfigFile); } } if (subProvider != null) { cmp.Add(subProvider); } } } AppCtx.Cache.AddObjectWithFileChange(typename, provider, ModelConfig.ConfigFilePath, GeneralConfigs.ConfigFile); } return(provider); }
internal DbDatabaseMapping BuildAndValidate(DbProviderInfo providerInfo, bool throwOnError, params Type[] unignoredTypes) { IgnoreAll(unignoredTypes); // Build and clone multiple times to check for idempotency issues. Build(providerInfo); var cloned = Clone(); var databaseMapping = cloned.Build(providerInfo).DatabaseMapping; //databaseMapping.ShellEdmx(); databaseMapping.AssertValid(throwOnError); return(databaseMapping); }
public static void Register(string configName, string providerName, string cmdParamNamePrefix, string defaultConnString, Func<string, string> func_3) { if (DbProviderInfoContainer.ContainsKey(configName)) { throw new InvalidOperationException(string.Format("配置项 [{0}] 已经注册过了。", configName)); } DbProviderInfo dbProviderInfo = new DbProviderInfo { dbProviderFactory = GetDbProviderFactory(providerName), ProviderName = providerName, CmdParamNamePrefix = cmdParamNamePrefix ?? string.Empty, DefaultConnString = defaultConnString, func = func_3 }; DbProviderInfoContainer.Add(configName, dbProviderInfo); Type type = dbProviderInfo.dbProviderFactory.CreateConnection().GetType(); dbProviderFactoryContainer[type] = dbProviderInfo.dbProviderFactory; }
internal static EdmModel CreateStoreModel( EntityContainer entityContainer, DbProviderInfo providerInfo, DbProviderManifest providerManifest, double schemaVersion = 3.0) { EdmModel edmModel = new EdmModel(entityContainer, schemaVersion); if (providerInfo != null) { edmModel.ProviderInfo = providerInfo; } if (providerManifest != null) { edmModel.ProviderManifest = providerManifest; } return(edmModel); }
internal DbModel BuildDynamicUpdateModel(DbProviderInfo providerInfo) { DebugCheck.NotNull(providerInfo); var model = Build(providerInfo); var entityContainerMapping = model.DatabaseMapping.EntityContainerMappings.Single(); entityContainerMapping .EntitySetMappings .Each(esm => esm.ClearModificationFunctionMappings()); entityContainerMapping .AssociationSetMappings .Each(asm => asm.ModificationFunctionMapping = null); return(model); }
public virtual string Calculate(DbCompiledModel compiledModel) { DbProviderInfo providerInfo = compiledModel.ProviderInfo; DbModelBuilder dbModelBuilder = compiledModel.CachedModelBuilder.Clone(); EdmMetadataContext.ConfigureEdmMetadata(dbModelBuilder.ModelConfiguration); EdmModel database = dbModelBuilder.Build(providerInfo).DatabaseMapping.Database; database.SchemaVersion = 2.0; StringBuilder stringBuilder = new StringBuilder(); StringBuilder output = stringBuilder; XmlWriterSettings settings = new XmlWriterSettings() { Indent = true }; using (XmlWriter xmlWriter = XmlWriter.Create(output, settings)) new SsdlSerializer().Serialize(database, providerInfo.ProviderInvariantName, providerInfo.ProviderManifestToken, xmlWriter, true); return(ModelHashCalculator.ComputeSha256Hash(stringBuilder.ToString())); }
public static StorageMappingItemCollection GetStorageMappingItemCollection( this XDocument model, out DbProviderInfo providerInfo) { EdmItemCollection edmCollection = new EdmItemCollection((IEnumerable <XmlReader>) new XmlReader[1] { model.Descendants(EdmXNames.Csdl.SchemaNames).Single <XElement>().CreateReader() }); XElement element = model.Descendants(EdmXNames.Ssdl.SchemaNames).Single <XElement>(); providerInfo = new DbProviderInfo(element.ProviderAttribute(), element.ProviderManifestTokenAttribute()); StoreItemCollection storeCollection = new StoreItemCollection((IEnumerable <XmlReader>) new XmlReader[1] { element.CreateReader() }); return(new StorageMappingItemCollection(edmCollection, storeCollection, (IEnumerable <XmlReader>) new XmlReader[1] { new XElement(model.Descendants(EdmXNames.Msl.MappingNames).Single <XElement>()).CreateReader() })); }
public static DbModel CreateModel(DbProviderInfo provider) { if (_chinookModel == null) { var builder = new DbModelBuilder(); builder.Entity <Genre>(); builder.Entity <MediaType>(); builder.Entity <Artist>(); builder.Entity <Album>(); builder.Entity <Track>(); builder.Entity <Employee>(); builder.Entity <Customer>(); builder.Entity <Invoice>(); builder.Entity <InvoiceLine>(); builder.Entity <Playlist>(); builder.Entity <PlaylistTrack>(); _chinookModel = builder.Build(provider); } return(_chinookModel); }
private static DbSpatialServices GetSpatialServices( IDbDependencyResolver resolver, DbProviderInfo key, Func <DbProviderServices> providerServices) // Delegate use to avoid lookup when not needed { DebugCheck.NotNull(resolver); DebugCheck.NotNull(key); DebugCheck.NotNull(providerServices); var services = _spatialServices.GetOrAdd( key, k => resolver.GetService <DbSpatialServices>(k) ?? providerServices().GetSpatialServicesInternal(k.ProviderManifestToken, throwIfNotImplemented: false) ?? resolver.GetService <DbSpatialServices>()); if (services == null) { throw new ProviderIncompatibleException(Strings.ProviderDidNotReturnSpatialServices); } return(services); }
private DbModel Build(DbProviderManifest providerManifest, DbProviderInfo providerInfo) { DebugCheck.NotNull(providerManifest); DebugCheck.NotNull(providerInfo); var model = new EdmModel(DataSpace.CSpace, _modelBuilderVersion.GetEdmVersion()) { ProviderInfo = providerInfo }; _conventionsConfiguration.ApplyModelConfiguration(_modelConfiguration); _modelConfiguration.NormalizeConfigurations(); MapTypes(model); _modelConfiguration.Configure(model); _conventionsConfiguration.ApplyModel(model); model.Validate(); var databaseMapping = model.GenerateDatabaseMapping(providerManifest); // Run the PluralizingTableNameConvention first so that the new table name is available for configuration _conventionsConfiguration.ApplyPluralizingTableNameConvention(databaseMapping.Database); _modelConfiguration.Configure(databaseMapping, providerManifest); _conventionsConfiguration.ApplyDatabase(databaseMapping.Database); _conventionsConfiguration.ApplyMapping(databaseMapping); databaseMapping.Database.ProviderManifest = providerManifest; databaseMapping.Database.ProviderInfo = providerInfo; databaseMapping.Database.Validate(); return(new DbModel(databaseMapping, Clone())); }
public DbModel Build(DbProviderInfo providerInfo, Uri contextUrl) { if (providerInfo == null) { throw new ArgumentNullException("providerInfo"); } if (contextUrl == null) { throw new ArgumentNullException("contextUrl"); } var boundedContextElement = LookupContext(contextUrl); if (boundedContextElement == null) { return(null); } var modelBuilder = SetupBuilder(boundedContextElement); return(modelBuilder.Build(providerInfo)); }
private static DbSpatialServices GetSpatialServices( IDbDependencyResolver resolver, DbProviderInfo key, Func <DbProviderServices> providerServices) // Delegate use to avoid lookup when not needed { DebugCheck.NotNull(resolver); DebugCheck.NotNull(key); DebugCheck.NotNull(providerServices); #pragma warning disable 612, 618 var services = _spatialServices.GetOrAdd( key, k => resolver.GetService <DbSpatialServices>(k) ?? providerServices().GetSpatialServices(k.ProviderManifestToken) ?? resolver.GetService <DbSpatialServices>()); #pragma warning restore 612, 618 if (services == null) { throw new ProviderIncompatibleException(Strings.ProviderDidNotReturnSpatialServices); } return(services); }