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);
}
/// <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;
}
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 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 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));
}
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 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 _));
}
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();
}
}
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);
}
/// <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;
}
