public void Prepare_returns_a_new_instance() { var objectQueryExecutionPlanFactory = new ObjectQueryExecutionPlanFactory( Common.Internal.Materialization.MockHelper.CreateTranslator <object>()); var metadataWorkspace = new MetadataWorkspace(); var edmItemCollection = new EdmItemCollection(); metadataWorkspace.RegisterItemCollection(edmItemCollection); metadataWorkspace.RegisterItemCollection(new ObjectItemCollection()); var fakeSqlProviderManifest = new FakeSqlProviderServices().GetProviderManifest("2008"); var storeItemCollection = new StoreItemCollection(FakeSqlProviderFactory.Instance, fakeSqlProviderManifest, "2008"); metadataWorkspace.RegisterItemCollection(storeItemCollection); metadataWorkspace.RegisterItemCollection( new StorageMappingItemCollection(edmItemCollection, storeItemCollection, Enumerable.Empty <XmlReader>())); var fakeSqlConnection = new FakeSqlConnection(); fakeSqlConnection.ConnectionString = "foo"; var entityConnection = new EntityConnection(metadataWorkspace, fakeSqlConnection, false); var objectContext = new ObjectContext(entityConnection); var dbExpression = new DbNullExpression(TypeUsage.Create(fakeSqlProviderManifest.GetStoreTypes().First())); var dbQueryCommandTree = new DbQueryCommandTree( metadataWorkspace, DataSpace.CSpace, dbExpression, validate: false); var parameters = new List <Tuple <ObjectParameter, QueryParameterExpression> >(); var objectQueryExecutionPlan = objectQueryExecutionPlanFactory.Prepare( objectContext, dbQueryCommandTree, typeof(object), MergeOption.NoTracking, new Span(), parameters, aliasGenerator: null); Assert.NotNull(objectQueryExecutionPlan); }
public void Prepare_returns_a_new_instance() { var objectQueryExecutionPlanFactory = new ObjectQueryExecutionPlanFactory( Common.Internal.Materialization.MockHelper.CreateTranslator<object>()); var metadataWorkspace = new MetadataWorkspace(); var edmItemCollection = new EdmItemCollection(); metadataWorkspace.RegisterItemCollection(edmItemCollection); metadataWorkspace.RegisterItemCollection(new ObjectItemCollection()); var fakeSqlProviderManifest = new FakeSqlProviderServices().GetProviderManifest("2008"); var storeItemCollection = new StoreItemCollection(FakeSqlProviderFactory.Instance, fakeSqlProviderManifest, "2008"); metadataWorkspace.RegisterItemCollection(storeItemCollection); metadataWorkspace.RegisterItemCollection(new StorageMappingItemCollection(edmItemCollection, storeItemCollection, Enumerable.Empty<XmlReader>())); var fakeSqlConnection = new FakeSqlConnection(); fakeSqlConnection.ConnectionString = "foo"; var entityConnection = new EntityConnection(metadataWorkspace, fakeSqlConnection, false); var objectContext = new ObjectContext(entityConnection); var dbExpression = new DbNullExpression(TypeUsage.Create(fakeSqlProviderManifest.GetStoreTypes().First())); var dbQueryCommandTree = new DbQueryCommandTree(metadataWorkspace, DataSpace.CSpace, dbExpression, validate: false); var parameters = new List<Tuple<ObjectParameter, QueryParameterExpression>>(); var objectQueryExecutionPlan = objectQueryExecutionPlanFactory.Prepare(objectContext, dbQueryCommandTree, typeof(object), MergeOption.NoTracking, new Span(), parameters, aliasGenerator: null); Assert.NotNull(objectQueryExecutionPlan); }
/// <summary> /// Initializes a new command tree with a given metadata workspace. /// </summary> /// <param name="metadata">The metadata workspace against which the command tree should operate.</param> /// <param name="dataSpace">The logical 'space' that metadata in the expressions used in this command tree must belong to.</param> internal DbCommandTree(MetadataWorkspace metadata, DataSpace dataSpace) { // Ensure the metadata workspace is non-null EntityUtil.CheckArgumentNull(metadata, "metadata"); // Ensure that the data space value is valid if (!DbCommandTree.IsValidDataSpace(dataSpace)) { throw EntityUtil.Argument(System.Data.Entity.Strings.Cqt_CommandTree_InvalidDataSpace, "dataSpace"); } // // Create the tree's metadata workspace and initalize commonly used types. // MetadataWorkspace effectiveMetadata = new MetadataWorkspace(); //While EdmItemCollection and StorageitemCollections are required //ObjectItemCollection may or may not be registered on the workspace yet. //So register the ObjectItemCollection if it exists. ItemCollection objectItemCollection; if (metadata.TryGetItemCollection(DataSpace.OSpace, out objectItemCollection)) { effectiveMetadata.RegisterItemCollection(objectItemCollection); } effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSpace)); effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSSpace)); effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.SSpace)); this._metadata = effectiveMetadata; this._dataSpace = dataSpace; }
/// <summary> /// Initializes a new command tree with a given metadata workspace. /// </summary> /// <param name="metadata">The metadata workspace against which the command tree should operate.</param> /// <param name="dataSpace">The logical 'space' that metadata in the expressions used in this command tree must belong to.</param> internal DbCommandTree(MetadataWorkspace metadata, DataSpace dataSpace) { // Ensure the metadata workspace is non-null //Contract.Requires(metadata != null); // Ensure that the data space value is valid if (!IsValidDataSpace(dataSpace)) { throw new ArgumentException(Strings.Cqt_CommandTree_InvalidDataSpace, "dataSpace"); } // // Create the tree's metadata workspace and initalize commonly used types. // var effectiveMetadata = new MetadataWorkspace(); //While EdmItemCollection and StorageitemCollections are required //ObjectItemCollection may or may not be registered on the workspace yet. //So register the ObjectItemCollection if it exists. ItemCollection objectItemCollection; if (metadata.TryGetItemCollection(DataSpace.OSpace, out objectItemCollection)) { effectiveMetadata.RegisterItemCollection(objectItemCollection); } effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSpace)); effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSSpace)); effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.SSpace)); _metadata = effectiveMetadata; _dataSpace = dataSpace; }
private static MetadataWorkspace CreateWrappedMetadataWorkspace(string metadata, IEnumerable <string> wrapperProviderNames) { MetadataWorkspace workspace = new MetadataWorkspace(); // parse Metadata keyword and load CSDL,SSDL,MSL files into XElement structures... var csdl = new List <XElement>(); var ssdl = new List <XElement>(); var msl = new List <XElement>(); ParseMetadata(metadata, csdl, ssdl, msl); // fix all SSDL files by changing 'Provider' to our provider and modifying foreach (var ssdlFile in ssdl) { foreach (string providerName in wrapperProviderNames) { ssdlFile.Attribute("ProviderManifestToken").Value = ssdl[0].Attribute("Provider").Value + ";" + ssdlFile.Attribute("ProviderManifestToken").Value; ssdlFile.Attribute("Provider").Value = providerName; } } // load item collections from XML readers created from XElements... EdmItemCollection eic = new EdmItemCollection(csdl.Select(c => c.CreateReader())); StoreItemCollection sic = new StoreItemCollection(ssdl.Select(c => c.CreateReader())); StorageMappingItemCollection smic = new StorageMappingItemCollection(eic, sic, msl.Select(c => c.CreateReader())); // and create metadata workspace based on them. workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(eic); workspace.RegisterItemCollection(sic); workspace.RegisterItemCollection(smic); return(workspace); }
private static MetadataWorkspace CreateWorkSpace() { string sql = @"select csdl,msl,ssdl from Chapter7.Definitions"; XmlReader csdlReader = null; XmlReader mslReader = null; XmlReader ssdlReader = null; using (var cn = new SqlConnection(connString)) { using (var cmd = new SqlCommand(sql, cn)) { cn.Open(); var reader = cmd.ExecuteReader(); if (reader.Read()) { csdlReader = reader.GetSqlXml(0).CreateReader(); mslReader = reader.GetSqlXml(1).CreateReader(); ssdlReader = reader.GetSqlXml(2).CreateReader(); } } } var workspace = new MetadataWorkspace(); var edmCollection = new EdmItemCollection(new XmlReader[] { csdlReader }); var ssdlCollection = new StoreItemCollection(new XmlReader[] { ssdlReader }); var mappingCollection = new StorageMappingItemCollection(edmCollection, ssdlCollection, new XmlReader[] { mslReader }); workspace.RegisterItemCollection(edmCollection); workspace.RegisterItemCollection(ssdlCollection); workspace.RegisterItemCollection(mappingCollection); return(workspace); }
private static MetadataWorkspace CreateMetadataWorkspace(XDocument cSpaceCsdl, Assembly assembly, bool isPOCO) { var workspace = new MetadataWorkspace(); EdmItemCollection edmItemCollection; using (var csdlReader = cSpaceCsdl.CreateReader()) { edmItemCollection = new EdmItemCollection(new XmlReader[] { csdlReader }); } workspace.RegisterItemCollection(edmItemCollection); // assembly can actually be an AssemblyBuilder. The following line ensures that we are // using the actual assembly otherwise an Assert in ObjectItemAttributeAssemblyLoader.LoadType // will fire. assembly = assembly.GetTypes().First().Assembly; var objectItemCollection = new ObjectItemCollection(); if (isPOCO) { objectItemCollection.LoadFromAssembly(assembly, edmItemCollection); } else { objectItemCollection.LoadFromAssembly(assembly); } workspace.RegisterItemCollection(objectItemCollection); return(workspace); }
/// <summary> /// Creates the MetadataWorkspace for the given context type and base context type. /// </summary> /// <param name="contextType">The type of the context.</param> /// <param name="baseContextType">The base context type (DbContext or ObjectContext).</param> /// <returns>The generated <see cref="System.Data.Entity.Core.Metadata.Edm.MetadataWorkspace"/></returns> public static MetadataWorkspace CreateMetadataWorkspaceFromResources(Type contextType, Type baseContextType) { // get the set of embedded mapping resources for the target assembly and create // a metadata workspace info for each group var metadataResourcePaths = FindMetadataResources(contextType.Assembly); var workspaceInfos = GetMetadataWorkspaceInfos(metadataResourcePaths); // Search for the correct EntityContainer by name and if found, create // a comlete MetadataWorkspace and return it foreach (var workspaceInfo in workspaceInfos) { var edmItemCollection = new EdmItemCollection(workspaceInfo.Csdl); var currentType = contextType; while (currentType != baseContextType && currentType != typeof (object)) { EntityContainer container; if (edmItemCollection.TryGetEntityContainer(currentType.Name, out container)) { var store = new StoreItemCollection(workspaceInfo.Ssdl); var mapping = new StorageMappingItemCollection(edmItemCollection, store, workspaceInfo.Msl); var workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(edmItemCollection); workspace.RegisterItemCollection(store); workspace.RegisterItemCollection(mapping); workspace.RegisterItemCollection(new ObjectItemCollection()); return workspace; } currentType = currentType.BaseType; } } return null; }
/// <summary> /// Creates the MetadataWorkspace for the given context type and base context type. /// </summary> /// <param name="contextType">The type of the context.</param> /// <param name="baseContextType">The base context type (DbContext or ObjectContext).</param> /// <returns>The generated <see cref="MetadataWorkspace"/></returns> public static MetadataWorkspace CreateMetadataWorkspaceFromResources(Type contextType, Type baseContextType) { // get the set of embedded mapping resources for the target assembly and create // a metadata workspace info for each group IEnumerable <string> metadataResourcePaths = FindMetadataResources(contextType.Assembly); IEnumerable <MetadataWorkspaceInfo> workspaceInfos = GetMetadataWorkspaceInfos(metadataResourcePaths); // Search for the correct EntityContainer by name and if found, create // a comlete MetadataWorkspace and return it foreach (var workspaceInfo in workspaceInfos) { EdmItemCollection edmItemCollection = new EdmItemCollection(workspaceInfo.Csdl); Type currentType = contextType; while (currentType != baseContextType && currentType != typeof(object)) { EntityContainer container; if (edmItemCollection.TryGetEntityContainer(currentType.Name, out container)) { StoreItemCollection store = new StoreItemCollection(workspaceInfo.Ssdl); StorageMappingItemCollection mapping = new StorageMappingItemCollection(edmItemCollection, store, workspaceInfo.Msl); MetadataWorkspace workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(edmItemCollection); workspace.RegisterItemCollection(store); workspace.RegisterItemCollection(mapping); workspace.RegisterItemCollection(new ObjectItemCollection()); return(workspace); } currentType = currentType.BaseType; } } return(null); }
public static void InitializeMetadataWorkspace(TestContext testContext) { StringReader sr = new StringReader(testCsdl); XmlReader reader = XmlReader.Create(sr); metadataWorkspace = new MetadataWorkspace(); EdmItemCollection edmItemCollection = new EdmItemCollection(new XmlReader[] { reader }); metadataWorkspace.RegisterItemCollection(edmItemCollection); metadataWorkspace.RegisterItemCollection(new ObjectItemCollection()); metadataWorkspace.LoadFromAssembly(Assembly.GetExecutingAssembly()); }
public void Can_load_entity_with_property_of_enum_type_from_different_assembly() { const bool isPOCO = true; var enumTypeCsdl = XDocument.Parse( @"<Schema xmlns=""http://schemas.microsoft.com/ado/2009/11/edm"" Namespace=""EnumModel""> <EnumType Name=""Enum"" IsFlags=""false"" /> </Schema>"); var entityTypeCsdl = XDocument.Parse( @"<Schema xmlns=""http://schemas.microsoft.com/ado/2009/11/edm"" Namespace=""EnumModel""> <EntityContainer Name=""EnumModelContainer""> <EntitySet Name=""Entity"" EntityType=""EnumModel.Entity"" /> </EntityContainer> <EntityType Name=""Entity""> <Key> <PropertyRef Name=""Id"" /> </Key> <Property Name=""Id"" Nullable=""false"" Type=""Int32"" /> <Property Name=""EnumProperty"" Nullable=""false"" Type=""EnumModel.Enum"" /> </EntityType> </Schema>"); var assemblyWithEnumType = BuildAssembly(isPOCO, enumTypeCsdl); var assemblyWithEntityType = BuildAssembly(isPOCO, entityTypeCsdl); EdmItemCollection edmItemCollection; var workspace = new MetadataWorkspace(); using (var enumTypeReader = enumTypeCsdl.CreateReader()) using (var entityTypeReader = entityTypeCsdl.CreateReader()) { edmItemCollection = new EdmItemCollection( new XmlReader[] { enumTypeReader, entityTypeReader }); } workspace.RegisterItemCollection(edmItemCollection); var objectItemCollection = new ObjectItemCollection(); objectItemCollection.LoadFromAssembly(assemblyWithEnumType, edmItemCollection); objectItemCollection.LoadFromAssembly(assemblyWithEntityType, edmItemCollection); workspace.RegisterItemCollection(objectItemCollection); Assert.Equal( "EnumModel.Entity:EnumModel.Entity", workspace.GetMap("EnumModel.Entity", DataSpace.OSpace, DataSpace.OCSpace).Identity); }
public static EntityConnection Create(List <ColumnsToRemove> tablesAndColumns, string connString) { var modelNameRegex = new Regex(@".*metadata=res:\/\/\*\/([a-zA-Z.]*).csdl|.*"); var model = modelNameRegex.Matches(connString).Cast <Match>().SelectMany(o => o.Groups.Cast <Group>().Skip(1).Where(oo => oo.Value != "")).Select(o => o.Value).First(); var conceptualReader = XmlReader.Create(Assembly.GetExecutingAssembly().GetManifestResourceStream(model + ".csdl")); var mappingReader = XmlReader.Create(Assembly.GetExecutingAssembly().GetManifestResourceStream(model + ".msl")); var storageReader = XmlReader.Create(Assembly.GetExecutingAssembly().GetManifestResourceStream(model + ".ssdl")); var conceptualXml = XElement.Load(conceptualReader); var mappingXml = XElement.Load(mappingReader); var storageXml = XElement.Load(storageReader); foreach (var entitySet in new[] { storageXml, conceptualXml }.SelectMany(xml => xml.Elements())) { if (entitySet.Attribute("Name").Value == "ModelStoreContainer") { foreach (var entityContainerEntitySet in entitySet.Elements()) { RemoveNodes(entityContainerEntitySet, tablesAndColumns); } } RemoveNodes(entitySet, tablesAndColumns); } foreach (var entitySet in mappingXml.Elements().ElementAt(0).Elements()) { if (entitySet.Name.LocalName == "EntitySetMapping") { foreach (var entityContainerEntitySet in entitySet.Elements().First().Elements()) { RemoveNodes(entityContainerEntitySet, tablesAndColumns); } } RemoveNodes(entitySet, tablesAndColumns); } var storageCollection = new StoreItemCollection(new [] { storageXml.CreateReader() }); var conceptualCollection = new EdmItemCollection(new[] { conceptualXml.CreateReader() }); var mappingCollection = new StorageMappingItemCollection(conceptualCollection, storageCollection, new[] { mappingXml.CreateReader() }); var workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(conceptualCollection); workspace.RegisterItemCollection(storageCollection); workspace.RegisterItemCollection(mappingCollection); var connectionData = new EntityConnectionStringBuilder(connString); var connection = DbProviderFactories .GetFactory(connectionData.Provider) .CreateConnection(); connection.ConnectionString = connectionData.ProviderConnectionString; return(new EntityConnection(workspace, connection)); }
/// <summary> /// Compiles eSQL <paramref name="functionDefinition" /> and returns <see cref="DbLambda" />. /// Guarantees type match of lambda variables and <paramref name="functionParameters" />. /// Passes thru all excepions coming from <see cref="CqlQuery" />. /// </summary> internal static DbLambda CompileFunctionDefinition( string functionDefinition, IList <FunctionParameter> functionParameters, EdmItemCollection edmItemCollection) { DebugCheck.NotNull(functionParameters); DebugCheck.NotNull(edmItemCollection); var workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(edmItemCollection); Perspective perspective = new ModelPerspective(workspace); // Since we compile lambda expression and generate variables from the function parameter definitions, // the returned DbLambda will contain variable types that match function parameter types. var functionBody = CqlQuery.CompileQueryCommandLambda( functionDefinition, perspective, null /* use default parser options */, null /* parameters */, functionParameters.Select(pInfo => pInfo.TypeUsage.Variable(pInfo.Name))); Debug.Assert(functionBody != null, "functionBody != null"); return(functionBody); }
private static MetadataWorkspace CreateWorkspace(XmlReader conceptualReader, XmlReader storageReader, XmlReader mappingReader) { var workspace = new MetadataWorkspace(); // Convert our XML data into workspace collections (the enumerable XmlReaders will be singletons) var conceptualCollection = new EdmItemCollection(conceptualReader.ToEnumerable()); var storageCollection = new StoreItemCollection(storageReader.ToEnumerable()); var mappingCollection = new StorageMappingItemCollection(conceptualCollection, storageCollection, mappingReader.ToEnumerable()); // Register our collections in the workspace workspace.RegisterItemCollection(conceptualCollection); workspace.RegisterItemCollection(storageCollection); workspace.RegisterItemCollection(mappingCollection); return(workspace); }
public void Registering_c_space_or_o_space_does_not_cause_oc_mapping_to_be_registered_if_it_is_already_registered() { var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(Csdl).CreateReader() }); var objectItemCollection = new ObjectItemCollection(); var ocMappingItemCollection = new DefaultObjectMappingItemCollection(edmItemCollection, objectItemCollection); var workspace = new MetadataWorkspace(); #pragma warning disable 612,618 workspace.RegisterItemCollection(ocMappingItemCollection); workspace.RegisterItemCollection(edmItemCollection); workspace.RegisterItemCollection(objectItemCollection); #pragma warning restore 612,618 Assert.Same(ocMappingItemCollection, workspace.GetItemCollection(DataSpace.OCSpace)); Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace)); Assert.Same(objectItemCollection, workspace.GetItemCollection(DataSpace.OSpace)); }
/// <summary> /// Generates metadata for given item collection. /// Fetches CLR models from given assembly. /// </summary> /// <param name="metadataWorkspace">The metadata workspace.</param> /// <param name="modelAssembly">The model assembly.</param> /// <param name="connectionString">The connection string.</param> /// <returns></returns> public static Metadata Generate(MetadataWorkspace metadataWorkspace, Assembly modelAssembly, string connectionString) { metadataWorkspace.RegisterItemCollection(new ObjectItemCollection()); metadataWorkspace.LoadFromAssembly(modelAssembly); var itemCollection = metadataWorkspace.GetItemCollection(DataSpace.CSpace); var objectItemCollection = (ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace); return Generate(metadataWorkspace, itemCollection, objectItemCollection, modelAssembly, connectionString); }
internal static MetadataWorkspace ToMetadataWorkspace(this DbDatabaseMapping databaseMapping) { Contract.Requires(databaseMapping != null); var metadataWorkspace = new MetadataWorkspace(); var itemCollection = databaseMapping.Model.ToEdmItemCollection(); var storeItemCollection = databaseMapping.Database.ToStoreItemCollection(); var storageMappingItemCollection = databaseMapping.ToStorageMappingItemCollection(itemCollection, storeItemCollection); metadataWorkspace.RegisterItemCollection(itemCollection); metadataWorkspace.RegisterItemCollection(storeItemCollection); metadataWorkspace.RegisterItemCollection(storageMappingItemCollection); return metadataWorkspace; }
Registering_o_space_causes_oc_mapping_to_also_be_registered_if_it_is_not_already_registered_and_c_space_is_registered() { var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() }); var objectItemCollection = new ObjectItemCollection(); var workspace = new MetadataWorkspace(); #pragma warning disable 612,618 workspace.RegisterItemCollection(edmItemCollection); workspace.RegisterItemCollection(objectItemCollection); #pragma warning restore 612,618 Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace)); Assert.Same(objectItemCollection, workspace.GetItemCollection(DataSpace.OSpace)); var ocMappingCollection = (DefaultObjectMappingItemCollection)workspace.GetItemCollection(DataSpace.OCSpace); Assert.Same(objectItemCollection, ocMappingCollection.ObjectItemCollection); Assert.Same(edmItemCollection, ocMappingCollection.EdmItemCollection); }
public static MetadataWorkspace ToMetadataWorkspace(this DbDatabaseMapping databaseMapping) { DebugCheck.NotNull(databaseMapping); var metadataWorkspace = new MetadataWorkspace(); var itemCollection = databaseMapping.Model.ToEdmItemCollection(); var storeItemCollection = databaseMapping.Database.ToStoreItemCollection(); var storageMappingItemCollection = databaseMapping.ToStorageMappingItemCollection(itemCollection, storeItemCollection); metadataWorkspace.RegisterItemCollection(itemCollection); metadataWorkspace.RegisterItemCollection(storeItemCollection); metadataWorkspace.RegisterItemCollection(storageMappingItemCollection); return(metadataWorkspace); }
/// <summary> /// Load the metadata for Edm, Store, and Mapping collections and register them /// with a new MetadataWorkspace, returns false if any of the parts can't be /// created, some of the ItemCollections may be registered and usable even if false is /// returned /// </summary> public bool TryLoadAllMetadata(string inputFile, out MetadataWorkspace metadataWorkspace) { metadataWorkspace = new MetadataWorkspace(); var edmItemCollection = CreateEdmItemCollection(inputFile); metadataWorkspace.RegisterItemCollection(edmItemCollection); StoreItemCollection storeItemCollection = null; if(TryCreateStoreItemCollection(inputFile, out storeItemCollection)) { StorageMappingItemCollection storageMappingItemCollection = null; if(TryCreateStorageMappingItemCollection(inputFile, edmItemCollection, storeItemCollection, out storageMappingItemCollection)) { metadataWorkspace.RegisterItemCollection(storeItemCollection); metadataWorkspace.RegisterItemCollection(storageMappingItemCollection); return true; } } return false; }
private static void Item_collections_can_be_registered(MetadataWorkspace workspace) { var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(Csdl).CreateReader() }); var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(Ssdl).CreateReader() }); var objectItemCollection = new ObjectItemCollection(); var storageMappingItemCollection = LoadMsl(edmItemCollection, storeItemCollection); var ocMappingItemCollection = new DefaultObjectMappingItemCollection(edmItemCollection, objectItemCollection); #pragma warning disable 612,618 workspace.RegisterItemCollection(edmItemCollection); workspace.RegisterItemCollection(storeItemCollection); workspace.RegisterItemCollection(objectItemCollection); workspace.RegisterItemCollection(storageMappingItemCollection); workspace.RegisterItemCollection(ocMappingItemCollection); #pragma warning restore 612,618 Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace)); Assert.Same(storeItemCollection, workspace.GetItemCollection(DataSpace.SSpace)); Assert.Same(storageMappingItemCollection, workspace.GetItemCollection(DataSpace.CSSpace)); Assert.Same(objectItemCollection, workspace.GetItemCollection(DataSpace.OSpace)); Assert.Same(ocMappingItemCollection, workspace.GetItemCollection(DataSpace.OCSpace)); }
public static MetadataWorkspace CreateMetadataWorkspace(List<XElement> csdl, List<XElement> ssdl, List<XElement> msl) { EdmItemCollection eic = new EdmItemCollection(csdl.Select(c => c.CreateReader())); StoreItemCollection sic = new StoreItemCollection(ssdl.Select(c => c.CreateReader())); StorageMappingItemCollection smic = new StorageMappingItemCollection(eic, sic, msl.Select(c => c.CreateReader())); // and create metadata workspace based on them. #if !EFOLD MetadataWorkspace workspace = new MetadataWorkspace( () => eic, () => sic, () => smic); #else // Obsolete API MetadataWorkspace workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(eic); workspace.RegisterItemCollection(sic); workspace.RegisterItemCollection(smic); #endif return workspace; }
public static MetadataWorkspace CreateMetadataWorkspace(List <XElement> csdl, List <XElement> ssdl, List <XElement> msl) { EdmItemCollection eic = new EdmItemCollection(csdl.Select(c => c.CreateReader())); StoreItemCollection sic = new StoreItemCollection(ssdl.Select(c => c.CreateReader())); StorageMappingItemCollection smic = new StorageMappingItemCollection(eic, sic, msl.Select(c => c.CreateReader())); // and create metadata workspace based on them. #if !EFOLD MetadataWorkspace workspace = new MetadataWorkspace( () => eic, () => sic, () => smic); #else // Obsolete API MetadataWorkspace workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(eic); workspace.RegisterItemCollection(sic); workspace.RegisterItemCollection(smic); #endif return(workspace); }
public void Registering_o_space_does_not_cause_oc_mapping_to_be_registered_if_c_space_is_not_registered() { var objectItemCollection = new ObjectItemCollection(); var workspace = new MetadataWorkspace(); #pragma warning disable 612,618 workspace.RegisterItemCollection(objectItemCollection); #pragma warning restore 612,618 Assert.Same(objectItemCollection, workspace.GetItemCollection(DataSpace.OSpace)); ItemCollection _; Assert.False(workspace.TryGetItemCollection(DataSpace.OCSpace, out _)); }
/// <summary> /// Load the metadata for Edm, Store, and Mapping collections and register them /// with a new MetadataWorkspace, returns false if any of the parts can't be /// created, some of the ItemCollections may be registered and usable even if false is /// returned /// </summary> public bool TryLoadAllMetadata(string inputFile, out MetadataWorkspace metadataWorkspace) { metadataWorkspace = new MetadataWorkspace(); EdmItemCollection edmItemCollection = CreateEdmItemCollection(inputFile); metadataWorkspace.RegisterItemCollection(edmItemCollection); StoreItemCollection storeItemCollection = null; if (TryCreateStoreItemCollection(inputFile, out storeItemCollection)) { StorageMappingItemCollection storageMappingItemCollection = null; if (TryCreateStorageMappingItemCollection(inputFile, edmItemCollection, storeItemCollection, out storageMappingItemCollection)) { metadataWorkspace.RegisterItemCollection(storeItemCollection); metadataWorkspace.RegisterItemCollection(storageMappingItemCollection); return(true); } } return(false); }
private static MetadataWorkspace LoadMetaDataFromResource() { // Load EDM meta data from resources in all used assemblies var workspace = new MetadataWorkspace(); try { var metaDataColl = new EdmItemCollection("res://*/"); workspace.RegisterItemCollection(metaDataColl); // TODO: Replace by non-obsolete variant. } catch (Exception) { // Log a critical message - in case of inproper // exception handling in the application //TODO Log a critical message - in case of inproper exception handling in the application ////var message = string.Format(CultureInfo.InvariantCulture, FrameworkMessage.ErrorLoadingEdmMetaData, ex.ToString()); ////Logger.Write(message, TraceEventType.Critical); // Rethrow throw; } return(workspace); }
private static XDocument UpdateCSpaceOSpaceMapping(XDocument xDoc, Assembly assembly, String resourcePrefix) { String[] res; if (resourcePrefix == "") { res = new string[] { "res://*/" }; } else { var pre = "res://*/" + resourcePrefix; res = new String[] { pre + ".csdl", pre + ".msl", pre + ".ssdl" }; } var metadataWs = new MetadataWorkspace( res, new Assembly[] { assembly }); // force an OSpace load - UGH - this was hard to find.... need to create the object item collection before loading assembly metadataWs.RegisterItemCollection(new ObjectItemCollection()); metadataWs.LoadFromAssembly(assembly); return(UpdateCSpaceOSpaceMappingCore(xDoc, metadataWs)); }
/// <summary> /// Compiles eSQL <paramref name="functionDefinition"/> and returns <see cref="DbLambda"/>. /// Guarantees type match of lambda variables and <paramref name="functionParameters"/>. /// Passes thru all excepions coming from <see cref="CqlQuery"/>. /// </summary> internal static DbLambda CompileFunctionDefinition( string functionDefinition, IList<FunctionParameter> functionParameters, EdmItemCollection edmItemCollection) { Debug.Assert(functionParameters != null, "functionParameters != null"); Debug.Assert(edmItemCollection != null, "edmItemCollection != null"); var workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(edmItemCollection); Perspective perspective = new ModelPerspective(workspace); // Since we compile lambda expression and generate variables from the function parameter definitions, // the returned DbLambda will contain variable types that match function parameter types. var functionBody = CqlQuery.CompileQueryCommandLambda( functionDefinition, perspective, null /* use default parser options */, null /* parameters */, functionParameters.Select(pInfo => pInfo.TypeUsage.Variable(pInfo.Name))); Debug.Assert(functionBody != null, "functionBody != null"); return functionBody; }
/// <summary> /// Creates the EntityConnection, based on new schema & existing connectionString /// </summary> /// <param name="schemaName">Name of the schema.</param> /// <param name="connectionBuilder"></param> /// <param name="modelName">Name of the model.</param> /// <returns></returns> public static EntityConnection CreateConnection(string schemaName, EntityConnectionStringBuilder connectionBuilder, string EntityName, Dictionary <string, string> Dict_EntitySchema) { Func <string, Stream> generateStream = extension => Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Concat(EntityName, extension)); // string DefaultSchemaName = WebConfigEncryption.Decrypt(ConfigurationManager.AppSettings["SchemaName"].ToString()); string DefaultSchemaName = "user"; Action <IEnumerable <Stream> > disposeCollection = streams => { if (streams == null) { return; } foreach (var stream in streams.Where(stream => stream != null)) { stream.Dispose(); } }; var conceptualReader = generateStream(".csdl"); var mappingReader = generateStream(".msl"); var storageReader = generateStream(".ssdl"); if (conceptualReader == null || mappingReader == null || storageReader == null) { disposeCollection(new[] { conceptualReader, mappingReader, storageReader }); return(null); } var storageXml = XElement.Load(storageReader); IEnumerable <XElement> Lst_Elements = storageXml.Descendants(); //"metadata=res://*/dataModel.userprofile.csdl //|res://*/dataModel.userprofile.ssdl //|res://*/dataModel.userprofile.msl; //provider=Npgsql; //provider connection string="Host=localhost;Database=iristest;Username=postgres;Password=tpstps_1;Persist Security Info=True"" foreach (var entitySet in Lst_Elements) { var schemaAttribute = entitySet.Attributes("Schema").FirstOrDefault(); if (schemaAttribute != null) { schemaAttribute.SetValue(schemaName); } } var reader1 = storageXml.CreateReader(); var workspace = new MetadataWorkspace(); var conceptualCollection = new EdmItemCollection(new[] { XmlReader.Create(conceptualReader) }); var storageCollection = new StoreItemCollection(new[] { storageXml.CreateReader() }); var mappingCollection = new StorageMappingItemCollection(conceptualCollection, storageCollection, new[] { XmlReader.Create(mappingReader) }); workspace.RegisterItemCollection(conceptualCollection); workspace.RegisterItemCollection(storageCollection); workspace.RegisterItemCollection(mappingCollection); var connection = DbProviderFactories.GetFactory(connectionBuilder.Provider).CreateConnection(); if (connection == null) { // disposeCollection(new[] { conceptualReader, mappingReader, storageReader }); return(null); } connection.ConnectionString = connectionBuilder.ProviderConnectionString; return(new EntityConnection(connection.ConnectionString)); }
public WSJDE() : base("name=WSJDE") { ObjectContext context = (this as IObjectContextAdapter).ObjectContext; string environment = ConfigurationManager.AppSettings.Get("Environment"); const string devCTL = "TESTCTL"; const string devDTA = "TESTDTA"; const string qaCTL = "CRPCTL"; const string qaDTA = "CRPDTA"; const string prodCTL = "PRODCTL"; const string prodDTA = "PRODDTA"; var x = Assembly.GetExecutingAssembly().GetManifestResourceStream("WSJDEData.WSJDE.ssdl"); XmlReader[] sReaders = new XmlReader[] { XmlReader.Create(Assembly.GetExecutingAssembly().GetManifestResourceStream("WSJDEData.WSJDE.ssdl")) }; XmlReader[] mReaders = new XmlReader[] { XmlReader.Create(Assembly.GetExecutingAssembly().GetManifestResourceStream("WSJDEData.WSJDE.msl")) }; StoreItemCollection sCollection = new StoreItemCollection(sReaders); ObjectContext objContext = ((IObjectContextAdapter)context).ObjectContext; MetadataWorkspace workspace = objContext.MetadataWorkspace; EdmItemCollection cCollection = workspace.GetItemCollection(DataSpace.CSpace) as EdmItemCollection; StorageMappingItemCollection csCollection = new StorageMappingItemCollection(cCollection, sCollection, mReaders); workspace.RegisterItemCollection(sCollection); workspace.RegisterItemCollection(csCollection); EntityContainer container = workspace.GetItem <EntityContainer>("WSJDEModelStoreContainer", DataSpace.SSpace); foreach (EntitySetBase entitySetBase in container.BaseEntitySets) { string schema = entitySetBase.Schema; if (schema != null) { string name = schema.Substring(schema.Length - 3); if (name == "CTL") { switch (environment) { case "Dev": typeof(EntitySetBase).GetField("_schema", BindingFlags.NonPublic | BindingFlags.Instance) .SetValue(entitySetBase, devCTL); break; case "QA": typeof(EntitySetBase).GetField("_schema", BindingFlags.NonPublic | BindingFlags.Instance) .SetValue(entitySetBase, qaCTL); break; case "Prod": typeof(EntitySetBase).GetField("_schema", BindingFlags.NonPublic | BindingFlags.Instance) .SetValue(entitySetBase, prodCTL); break; } } if (name == "DTA") { switch (environment) { case "Dev": typeof(EntitySetBase).GetField("_schema", BindingFlags.NonPublic | BindingFlags.Instance) .SetValue(entitySetBase, devDTA); break; case "QA": typeof(EntitySetBase).GetField("_schema", BindingFlags.NonPublic | BindingFlags.Instance) .SetValue(entitySetBase, qaDTA); break; case "Prod": typeof(EntitySetBase).GetField("_schema", BindingFlags.NonPublic | BindingFlags.Instance) .SetValue(entitySetBase, prodDTA); break; } } } } }
private bool SetEntityConnection(List<string> metadataPaths, EntityConnectionStringBuilder connStrBuilder) { // It's possible the metadata was specified in the original connection string, but we filtered out everything due to not being able to resolve it to anything. // In that case, warnings have already been displayed to indicate which paths were removed, so no need to display another message. if (metadataPaths.Count > 0) { try { // Get the connection first, because it might be needed to gather provider services information DbConnection dbConnection = GetDbConnection(connStrBuilder); MetadataWorkspace metadataWorkspace = new MetadataWorkspace(metadataPaths, _assemblies); // Ensure that we have all of the item collections registered. If some of them are missing this will cause problems eventually if we need to // execute a query to get detailed schema information, but that will be handled later. For now just register everything to prevent errors in the // stack that would not be understood by the user in the designer at this point. ItemCollection edmItemCollection; ItemCollection storeItemCollection; ItemCollection csItemCollection; if (!metadataWorkspace.TryGetItemCollection(DataSpace.CSpace, out edmItemCollection)) { edmItemCollection = new EdmItemCollection(); metadataWorkspace.RegisterItemCollection(edmItemCollection); } if (!metadataWorkspace.TryGetItemCollection(DataSpace.SSpace, out storeItemCollection)) { return false; } if (!metadataWorkspace.TryGetItemCollection(DataSpace.CSSpace, out csItemCollection)) { Debug.Assert(edmItemCollection != null && storeItemCollection != null, "edm and store ItemCollection should be populated already"); metadataWorkspace.RegisterItemCollection(new StorageMappingItemCollection(edmItemCollection as EdmItemCollection, storeItemCollection as StoreItemCollection)); } // Create an ObjectItemCollection beforehand so that we can load objects by-convention metadataWorkspace.RegisterItemCollection(new ObjectItemCollection()); // Load OSpace metadata from all of the assemblies we know about foreach (Assembly assembly in _assemblies) { metadataWorkspace.LoadFromAssembly(assembly); } if (dbConnection != null) { _entityConnection = new EntityConnection(metadataWorkspace, dbConnection); return true; } // else the DbConnection could not be created and the error should have already been displayed } catch (Exception ex) { StringBuilder exceptionMessage = new StringBuilder(); exceptionMessage.AppendLine(Strings.Error_MetadataLoadError); exceptionMessage.AppendLine(); exceptionMessage.Append(ex.Message); ShowError(exceptionMessage.ToString()); } } return false; }
private static MetadataWorkspace CreateWrappedMetadataWorkspace(string metadata, IEnumerable<string> wrapperProviderNames) { MetadataWorkspace workspace = new MetadataWorkspace(); // parse Metadata keyword and load CSDL,SSDL,MSL files into XElement structures... var csdl = new List<XElement>(); var ssdl = new List<XElement>(); var msl = new List<XElement>(); ParseMetadata(metadata, csdl, ssdl, msl); // fix all SSDL files by changing 'Provider' to our provider and modifying foreach (var ssdlFile in ssdl) { foreach (string providerName in wrapperProviderNames) { ssdlFile.Attribute("ProviderManifestToken").Value = ssdl[0].Attribute("Provider").Value + ";" + ssdlFile.Attribute("ProviderManifestToken").Value; ssdlFile.Attribute("Provider").Value = providerName; } } // load item collections from XML readers created from XElements... EdmItemCollection eic = new EdmItemCollection(csdl.Select(c => c.CreateReader())); StoreItemCollection sic = new StoreItemCollection(ssdl.Select(c => c.CreateReader())); StorageMappingItemCollection smic = new StorageMappingItemCollection(eic, sic, msl.Select(c => c.CreateReader())); // and create metadata workspace based on them. workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(eic); workspace.RegisterItemCollection(sic); workspace.RegisterItemCollection(smic); return workspace; }
private static void LoadStoreItemCollections(MetadataWorkspace workspace, DbConnection storeConnection, DbProviderFactory factory, DbConnectionOptions connectionOptions, EdmItemCollection edmItemCollection, MetadataArtifactLoader artifactLoader) { Debug.Assert(workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace), "C-Space must be loaded before loading S or C-S space"); // The provider connection string is optional; if it has not been specified, // we pick up the store's connection string. // string providerConnectionString = connectionOptions[EntityConnectionStringBuilder.ProviderConnectionStringParameterName]; if (string.IsNullOrEmpty(providerConnectionString) && (storeConnection != null)) { providerConnectionString = storeConnection.ConnectionString; } // Build a string as the key and look up the MetadataCache for a match string storeCacheKey = CreateMetadataCacheKey(artifactLoader.GetOriginalPaths(), connectionOptions[EntityConnectionStringBuilder.ProviderParameterName], providerConnectionString); // Load store metadata. object entryToken; StorageMappingItemCollection mappingCollection = MetadataCache.GetOrCreateStoreAndMappingItemCollections(storeCacheKey, artifactLoader, edmItemCollection, out entryToken); workspace.RegisterItemCollection(mappingCollection.StoreItemCollection); workspace.RegisterItemCollection(mappingCollection); // Adding the store metadata entry token to the workspace workspace.AddMetadataEntryToken(entryToken); }
private static EdmItemCollection LoadEdmItemCollection(MetadataWorkspace workspace, MetadataArtifactLoader artifactLoader) { // Build a string as the key and look up the MetadataCache for a match string edmCacheKey = CreateMetadataCacheKey(artifactLoader.GetOriginalPaths(DataSpace.CSpace), null, null); // Check the MetadataCache for an entry with this key object entryToken; EdmItemCollection edmItemCollection = MetadataCache.GetOrCreateEdmItemCollection(edmCacheKey, artifactLoader, out entryToken); workspace.RegisterItemCollection(edmItemCollection); // Adding the edm metadata entry token to the workspace, to make sure that this token remains alive till workspace is alive workspace.AddMetadataEntryToken(entryToken); return edmItemCollection; }
/// <summary> /// Creates 'transient' metadataworkspace based on store schema (EntityContainer) and trivial C-S mapping /// </summary> /// <param name="entityContainer"></param> /// <param name="session"></param> /// <returns></returns> private MetadataWorkspace CreateMetadataWorkspace(EntityContainer entityContainer, LoadMethodSessionState session) { MetadataWorkspace metadataWorkspace = new MetadataWorkspace(); EntityModelSchemaGenerator modelGen = new EntityModelSchemaGenerator(entityContainer); modelGen.GenerateForeignKeyProperties = this.GenerateForeignKeyProperties; IEnumerable<EdmSchemaError> errors = modelGen.GenerateMetadata(); if (EntityStoreSchemaGenerator.HasErrorSeverityErrors(errors)) { // this is a 'transient' metadataworkspace // no errors from this metadataworkspace should be shown to the user return null; } // register edmitemcollection metadataWorkspace.RegisterItemCollection(modelGen.EdmItemCollection); // register StoreItemCollection metadataWorkspace.RegisterItemCollection(session.ItemCollection); // register mapping using (MemoryStream memStream = new MemoryStream()) { using (XmlWriter xmlWriter = XmlWriter.Create(memStream)) { modelGen.WriteStorageMapping(xmlWriter); xmlWriter.Close(); } memStream.Seek(0, SeekOrigin.Begin); using (XmlReader xmlReader = XmlReader.Create(memStream)) { List<XmlReader> xmlReaders = new List<XmlReader>(); xmlReaders.Add(xmlReader); metadataWorkspace.RegisterItemCollection(new StorageMappingItemCollection(modelGen.EdmItemCollection, session.ItemCollection, xmlReaders)); } } return metadataWorkspace; }
public static EntityConnection Create( List <DatabaseSpecificModification> tableAndColumn, string connString, string model) { var conceptualReader = XmlReader.Create( Assembly .GetExecutingAssembly() .GetManifestResourceStream(model + ".csdl") ); var mappingReader = XmlReader.Create( Assembly .GetExecutingAssembly() .GetManifestResourceStream(model + ".msl") ); var storageReader = XmlReader.Create( Assembly .GetExecutingAssembly() .GetManifestResourceStream(model + ".ssdl") ); var conceptualXml = XElement.Load(conceptualReader); var mappingXml = XElement.Load(mappingReader); var storageXml = XElement.Load(storageReader); Action <XElement> removeNodes = (element) => { if (element.Attribute("Name") != null && tableAndColumn.Any(oo => oo.Table == element.Attribute("Name").Value&& !oo.IsAdd) || element.Attribute("StoreEntitySet") != null && tableAndColumn.Any(oo => oo.Table == element.Attribute("StoreEntitySet").Value&& !oo.IsAdd)) { var matchingSelectParts = tableAndColumn.Where(oo => element.Value.Contains(string.Format("\"{0}\".\"{1}\" AS \"{1}\"", oo.Table, oo.Column)) && !oo.IsAdd); if (matchingSelectParts.Any()) { foreach (var matchingSelectPart in matchingSelectParts) { var definingQuery = element.ElementsAnyNS("DefiningQuery").Single(); definingQuery.Value = definingQuery.Value.Replace(string.Format(", \n\"{0}\".\"{1}\" AS \"{1}\"", matchingSelectPart.Table, matchingSelectPart.Column), ""); } } else { var nodes = element.Nodes() .Where(o => o is XElement && ((XElement)o).Attribute("Name") != null && tableAndColumn.Any(oo => ((XElement)o).Attribute("Name").Value == oo.Column && !oo.IsAdd)); foreach (var node in nodes.ToList()) { node.Remove(); } } } }; foreach (var entitySet in storageXml.Elements()) { if (entitySet.Attribute("Name").Value == "ModelStoreContainer") { foreach (var entityContainerEntitySet in entitySet.Elements()) { removeNodes(entityContainerEntitySet); } } removeNodes(entitySet); } foreach (var entitySet in conceptualXml.Elements()) { if (entitySet.Attribute("Name").Value == "ModelStoreContainer") { foreach (var entityContainerEntitySet in entitySet.Elements()) { removeNodes(entityContainerEntitySet); } } removeNodes(entitySet); } foreach (var entitySet in mappingXml.Elements().ElementAt(0).Elements()) { if (entitySet.Name.LocalName == "EntitySetMapping") { foreach (var entityContainerEntitySet in entitySet.Elements().First().Elements()) { removeNodes(entityContainerEntitySet); } } removeNodes(entitySet); } storageXml.CreateReader(); StoreItemCollection storageCollection = new StoreItemCollection( new XmlReader[] { storageXml.CreateReader() } ); EdmItemCollection conceptualCollection = new EdmItemCollection(new [] { conceptualXml.CreateReader() }); StorageMappingItemCollection mappingCollection = new StorageMappingItemCollection( conceptualCollection, storageCollection, new [] { mappingXml.CreateReader() } ); var workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(conceptualCollection); workspace.RegisterItemCollection(storageCollection); workspace.RegisterItemCollection(mappingCollection); var connectionData = new EntityConnectionStringBuilder(connString); var connection = DbProviderFactories .GetFactory(connectionData.Provider) .CreateConnection(); connection.ConnectionString = connectionData.ProviderConnectionString; return(new EntityConnection(workspace, connection)); }
/// <summary> /// Creates the EntityConnection, based on new schema & existing connectionString /// </summary> /// <param name="schemaName">Name of the schema.</param> /// <param name="connectionBuilder"></param> /// <param name="modelName">Name of the model.</param> /// <returns></returns> private static EntityConnection CreateConnection(string schemaName, EntityConnectionStringBuilder connectionBuilder, string modelName) { Func <string, Stream> generateStream = extension => Assembly.GetExecutingAssembly().GetManifestResourceStream(string.Concat(modelName, extension)); Action <IEnumerable <Stream> > disposeCollection = streams => { if (streams == null) { return; } foreach (var stream in streams.Where(stream => stream != null)) { stream.Dispose(); } }; var conceptualReader = generateStream(".csdl"); var mappingReader = generateStream(".msl"); var storageReader = generateStream(".ssdl"); if (conceptualReader == null || mappingReader == null || storageReader == null) { disposeCollection(new[] { conceptualReader, mappingReader, storageReader }); return(null); } var storageXml = XElement.Load(storageReader); foreach (var entitySet in storageXml.Descendants()) { var schemaAttribute = entitySet.Attributes("Schema").FirstOrDefault(); if (schemaAttribute != null) { schemaAttribute.SetValue(schemaName); } } storageXml.CreateReader(); var workspace = new MetadataWorkspace(); var storageCollection = new StoreItemCollection(new[] { storageXml.CreateReader() }); var conceptualCollection = new EdmItemCollection(new[] { XmlReader.Create(conceptualReader) }); var mappingCollection = new StorageMappingItemCollection(conceptualCollection, storageCollection, new[] { XmlReader.Create(mappingReader) }); workspace.RegisterItemCollection(conceptualCollection); workspace.RegisterItemCollection(storageCollection); workspace.RegisterItemCollection(mappingCollection); var connection = DbProviderFactories.GetFactory(connectionBuilder.Provider).CreateConnection(); if (connection == null) { disposeCollection(new[] { conceptualReader, mappingReader, storageReader }); return(null); } connection.ConnectionString = connectionBuilder.ProviderConnectionString; return(new EntityConnection(workspace, connection)); }
private static void Item_collections_can_be_registered(MetadataWorkspace workspace) { var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(_csdlV3).CreateReader() }); var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(_ssdlV3).CreateReader() }); var objectItemCollection = new ObjectItemCollection(); var storageMappingItemCollection = LoadMsl(edmItemCollection, storeItemCollection); var ocMappingItemCollection = new DefaultObjectMappingItemCollection(edmItemCollection, objectItemCollection); #pragma warning disable 612,618 workspace.RegisterItemCollection(edmItemCollection); workspace.RegisterItemCollection(storeItemCollection); workspace.RegisterItemCollection(objectItemCollection); workspace.RegisterItemCollection(storageMappingItemCollection); workspace.RegisterItemCollection(ocMappingItemCollection); #pragma warning restore 612,618 Assert.Same(edmItemCollection, workspace.GetItemCollection(DataSpace.CSpace)); Assert.Same(storeItemCollection, workspace.GetItemCollection(DataSpace.SSpace)); Assert.Same(storageMappingItemCollection, workspace.GetItemCollection(DataSpace.CSSpace)); Assert.Same(objectItemCollection, workspace.GetItemCollection(DataSpace.OSpace)); Assert.Same(ocMappingItemCollection, workspace.GetItemCollection(DataSpace.OCSpace)); }
private static MetadataWorkspace GetProviderSchemaMetadataWorkspace(DbProviderServices providerServices, DbConnection providerConnection, Version targetEntityFrameworkVersion) { XmlReader csdl = null; XmlReader ssdl = null; XmlReader msl = null; Debug.Assert(EntityFrameworkVersions.IsValidVersion(targetEntityFrameworkVersion), "EntityFrameworkVersions.IsValidVersion(targetEntityFrameworkVersion)"); string csdlName; string ssdlName; string mslName; if (targetEntityFrameworkVersion >= EntityFrameworkVersions.Version3) { csdlName = DbProviderManifest.ConceptualSchemaDefinitionVersion3; ssdlName = DbProviderManifest.StoreSchemaDefinitionVersion3; mslName = DbProviderManifest.StoreSchemaMappingVersion3; } else { csdlName = DbProviderManifest.ConceptualSchemaDefinition; ssdlName = DbProviderManifest.StoreSchemaDefinition; mslName = DbProviderManifest.StoreSchemaMapping; } try { // create the metadata workspace MetadataWorkspace workspace = new MetadataWorkspace(); string manifestToken = providerServices.GetProviderManifestToken(providerConnection); DbProviderManifest providerManifest = providerServices.GetProviderManifest(manifestToken); // create the EdmItemCollection IList<EdmSchemaError> errors; ssdl = providerManifest.GetInformation(ssdlName); string location = Strings.DbProviderServicesInformationLocationPath(providerConnection.GetType().Name, ssdlName); List<string> ssdlLocations = new List<string>(1); ssdlLocations.Add(location); StoreItemCollection storeItemCollection = new StoreItemCollection(new XmlReader[] { ssdl }, ssdlLocations.AsReadOnly(), out errors); ThrowOnError(errors); workspace.RegisterItemCollection(storeItemCollection); csdl = DbProviderServices.GetConceptualSchemaDefinition(csdlName); location = Strings.DbProviderServicesInformationLocationPath(typeof(DbProviderServices).Name, csdlName); List<string> csdlLocations = new List<string>(1); csdlLocations.Add(location); EdmItemCollection edmItemCollection = new EdmItemCollection(new XmlReader[] { csdl }, csdlLocations.AsReadOnly(), out errors); ThrowOnError(errors); workspace.RegisterItemCollection(edmItemCollection); msl = providerManifest.GetInformation(mslName); location = Strings.DbProviderServicesInformationLocationPath(providerConnection.GetType().Name, DbProviderManifest.StoreSchemaMapping); List<string> mslLocations = new List<string>(1); mslLocations.Add(location); StorageMappingItemCollection mappingItemCollection = new StorageMappingItemCollection(edmItemCollection, storeItemCollection, new XmlReader[] { msl }, mslLocations, out errors); ThrowOnError(errors); workspace.RegisterItemCollection(mappingItemCollection); // make the views generate here so we can wrap the provider schema problems // in a ProviderIncompatibleException ForceViewGeneration(workspace); return workspace; } catch (ProviderIncompatibleException) { // we don't really want to catch this one, just rethrow it throw; } catch (Exception e) { if (MetadataUtil.IsCatchableExceptionType(e)) { throw EDesignUtil.ProviderIncompatible(Strings.ProviderSchemaErrors, e); } throw; } finally { if (csdl != null) ((IDisposable)csdl).Dispose(); if (ssdl != null) ((IDisposable)ssdl).Dispose(); if (msl != null) ((IDisposable)msl).Dispose(); } }
/// <summary> /// Creates the MetadataWorkspace for the given context type and base context type. /// </summary> /// <param name="contextType">The type of the context.</param> /// <param name="baseContextType">The base context type (DbContext or ObjectContext).</param> /// <returns>The generated <see cref="MetadataWorkspace"/></returns> public static MetadataWorkspace CreateMetadataWorkspaceFromResources(Type contextType, Type baseContextType) { // get the set of embedded mapping resources for the target assembly and create // a metadata workspace info for each group IEnumerable<string> metadataResourcePaths = FindMetadataResources(contextType.Assembly); IEnumerable<MetadataWorkspaceInfo> workspaceInfos = GetMetadataWorkspaceInfos(metadataResourcePaths); // Search for the correct EntityContainer by name and if found, create // a comlete MetadataWorkspace and return it foreach (var workspaceInfo in workspaceInfos) { EdmItemCollection edmItemCollection = new EdmItemCollection(workspaceInfo.Csdl); Type currentType = contextType; while (currentType != baseContextType && currentType != typeof(object)) { EntityContainer container; if (edmItemCollection.TryGetEntityContainer(currentType.Name, out container)) { StoreItemCollection store = new StoreItemCollection(workspaceInfo.Ssdl); #if DBCONTEXT // This actually means EF6+ MetadataWorkspace workspace = new MetadataWorkspace( () => edmItemCollection, () => store, () => new StorageMappingItemCollection(edmItemCollection, store, workspaceInfo.Msl), () => new ObjectItemCollection()); #else // EF4 StorageMappingItemCollection mapping = new StorageMappingItemCollection(edmItemCollection, store, workspaceInfo.Msl); MetadataWorkspace workspace = new MetadataWorkspace(); workspace.RegisterItemCollection(edmItemCollection); workspace.RegisterItemCollection(store); workspace.RegisterItemCollection(mapping); workspace.RegisterItemCollection(new ObjectItemCollection()); #endif return workspace; } currentType = currentType.BaseType; } } return null; }