/// <summary> /// Constructs a grouper based on the contents of the given entity state manager. /// </summary> /// <param name="stateManager">Entity state manager containing changes to be processed.</param> /// <param name="metadataWorkspace">Metadata workspace.</param> /// <param name="connection">Map connection</param> /// <param name="commandTimeout">Timeout for update commands; null means 'use provider default'</param> private UpdateTranslator(IEntityStateManager stateManager, MetadataWorkspace metadataWorkspace, EntityConnection connection, int? commandTimeout) { EntityUtil.CheckArgumentNull(stateManager, "stateManager"); EntityUtil.CheckArgumentNull(metadataWorkspace, "metadataWorkspace"); EntityUtil.CheckArgumentNull(connection, "connection"); // propagation state m_changes = new Dictionary<EntitySetBase, ChangeNode>(); m_functionChanges = new Dictionary<EntitySetBase, List<ExtractedStateEntry>>(); m_stateEntries = new List<IEntityStateEntry>(); m_knownEntityKeys = new Set<EntityKey>(); m_requiredEntities = new Dictionary<EntityKey, AssociationSet>(); m_optionalEntities = new Set<EntityKey>(); m_includedValueEntities = new Set<EntityKey>(); // workspace state m_metadataWorkspace = metadataWorkspace; m_viewLoader = metadataWorkspace.GetUpdateViewLoader(); m_stateManager = stateManager; // ancillary propagation services m_recordConverter = new RecordConverter(this); m_constraintValidator = new RelationshipConstraintValidator(this); m_providerServices = DbProviderServices.GetProviderServices(connection.StoreProviderFactory); m_connection = connection; m_commandTimeout = commandTimeout; // metadata cache m_extractorMetadata = new Dictionary<Tuple<EntitySetBase, StructuralType>, ExtractorMetadata>(); ; // key management KeyManager = new KeyManager(this); KeyComparer = CompositeKey.CreateComparer(KeyManager); }
/// <summary> /// Retrieves a mapping to CLR type for the given EDM type. Assumes the MetadataWorkspace has no /// </summary> internal static ObjectTypeMapping GetObjectMapping(EdmType type, MetadataWorkspace workspace) { // Check if the workspace has cspace item collection registered with it. If not, then its a case // of public materializer trying to create objects from PODR or EntityDataReader with no context. ItemCollection collection; if (workspace.TryGetItemCollection(DataSpace.CSpace, out collection)) { return (ObjectTypeMapping)workspace.GetMap(type, DataSpace.OCSpace); } else { EdmType ospaceType; EdmType cspaceType; // If its a case of EntityDataReader with no context, the typeUsage which is passed in must contain // a cspace type. We need to look up an OSpace type in the ospace item collection and then create // ocMapping if (type.DataSpace == DataSpace.CSpace) { // if its a primitive type, then the names will be different for CSpace type and OSpace type if (Helper.IsPrimitiveType(type)) { ospaceType = workspace.GetMappedPrimitiveType(((PrimitiveType)type).PrimitiveTypeKind, DataSpace.OSpace); } else { // Metadata will throw if there is no item with this identity present. // Is this exception fine or does object materializer code wants to wrap and throw a new exception ospaceType = workspace.GetItem<EdmType>(type.FullName, DataSpace.OSpace); } cspaceType = type; } else { // In case of PODR, there is no cspace at all. We must create a fake ocmapping, with ospace types // on both the ends ospaceType = type; cspaceType = type; } // This condition must be hit only when someone is trying to materialize a legacy data reader and we // don't have the CSpace metadata. if (!Helper.IsPrimitiveType(ospaceType) && !Helper.IsEntityType(ospaceType) && !Helper.IsComplexType(ospaceType)) { throw EntityUtil.MaterializerUnsupportedType(); } ObjectTypeMapping typeMapping; if (Helper.IsPrimitiveType(ospaceType)) { typeMapping = new ObjectTypeMapping(ospaceType, cspaceType); } else { typeMapping = DefaultObjectMappingItemCollection.LoadObjectMapping(cspaceType, ospaceType, null); } return typeMapping; } }
internal DbDeleteCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate) : base(metadata, dataSpace, target) { EntityUtil.CheckArgumentNull(predicate, "predicate"); this._predicate = predicate; }
private IEnumerable<KeyValuePair<Shaper<RecordState>, CoordinatorFactory<RecordState>>> GetNextResultShaperInfo( DbDataReader storeDataReader, MetadataWorkspace workspace, IEnumerable<ColumnMap> nextResultColumnMaps) { // It is important to do this lazily as the storeDataReader will have advanced to the next result set // by the time this IEnumerable is advanced return nextResultColumnMaps.Select(nextResultColumnMap => CreateShaperInfo(storeDataReader, nextResultColumnMap, workspace)); }
/// <summary> /// Creates a new command /// </summary> internal Command(MetadataWorkspace metadataWorkspace) { m_parameterMap = new Dictionary<string, ParameterVar>(); m_vars = new List<Var>(); m_tables = new List<Table>(); m_metadataWorkspace = metadataWorkspace; if(!TryGetPrimitiveType(PrimitiveTypeKind.Boolean, out m_boolType)) { throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.Cqt_General_NoProviderBooleanType); } if (!TryGetPrimitiveType(PrimitiveTypeKind.Int32, out m_intType)) { throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.Cqt_General_NoProviderIntegerType); } if (!TryGetPrimitiveType(PrimitiveTypeKind.String, out m_stringType)) { throw EntityUtil.ProviderIncompatible(System.Data.Entity.Strings.Cqt_General_NoProviderStringType); } m_trueOp = new ConstantPredicateOp(m_boolType, true); m_falseOp = new ConstantPredicateOp(m_boolType, false); m_nodeInfoVisitor = new NodeInfoVisitor(this); m_keyPullupVisitor = new PlanCompiler.KeyPullup(this); // FreeLists m_freeVarVecEnumerators = new Stack<VarVec.VarVecEnumerator>(); m_freeVarVecs = new Stack<VarVec>(); m_referencedRelProperties = new HashSet<RelProperty>(); }
/// <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; }
internal DbModificationCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target) : base(metadata, dataSpace) { EntityUtil.CheckArgumentNull(target, "target"); this._target = target; }
internal DbDeleteCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate) : base(metadata, dataSpace, target) { Contract.Requires(predicate != null); _predicate = predicate; }
/// <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; }
internal DbModificationCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target) : base(metadata, dataSpace) { Contract.Requires(target != null); _target = target; }
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 instance of the <see cref="DbDeleteCommandTree"/> class. /// </summary> /// <param name="metadata">The model this command will operate on.</param> /// <param name="dataSpace">The data space.</param> /// <param name="target">The target table for the data manipulation language (DML) operation.</param> /// <param name="predicate">A predicate used to determine which members of the target collection should be deleted.</param> public DbDeleteCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate) : base(metadata, dataSpace, target) { DebugCheck.NotNull(predicate); _predicate = predicate; }
/// <summary> /// Creates the full database scan expression. /// </summary> /// <param name="workspace"> /// The workspace that contains the metadata of the database /// </param> /// <param name="entitySet"> /// The entity set that is being scanned. /// </param> /// <returns> /// The DbCommandTree object. /// </returns> public static DbCommandTree CreateSelectAll( MetadataWorkspace workspace, EntitySet entitySet) { #if !EFOLD var scanExpression = DbExpressionBuilder.Scan(entitySet); return new DbQueryCommandTree(workspace, DataSpace.SSpace, scanExpression); #else var treeConstructor = typeof(DbQueryCommandTree) .GetConstructor( BindingFlags.NonPublic | BindingFlags.Instance, null, new Type[] { typeof(MetadataWorkspace), typeof(DataSpace), typeof(DbExpression) }, null); var expressionBuilderType = typeof(DbExpression).Assembly.GetType( "System.Data.Common.CommandTrees.ExpressionBuilder.DbExpressionBuilder"); var scanExpression = expressionBuilderType .GetMethod("Scan") .Invoke(null, new object[] { entitySet }); var tree = treeConstructor.Invoke( new object[] { workspace, DataSpace.SSpace, scanExpression }); return tree as DbCommandTree; #endif }
public void Pregenerated_views_are_found_for_EDMX_model() { var edmItemCollection = new EdmItemCollection(new[] { XDocument.Parse(PregenContextEdmx.Csdl).CreateReader() }); var storeItemCollection = new StoreItemCollection(new[] { XDocument.Parse(PregenContextEdmx.Ssdl).CreateReader() }); IList<EdmSchemaError> errors; var storageMappingItemCollection = StorageMappingItemCollection.Create( edmItemCollection, storeItemCollection, new[] { XDocument.Parse(PregenContextEdmx.Msl).CreateReader() }, null, out errors); var workspace = new MetadataWorkspace( () => edmItemCollection, () => storeItemCollection, () => storageMappingItemCollection); using (var context = new PregenContextEdmx(workspace)) { var _ = context.Blogs.ToString(); // Trigger view loading Assert.True(PregenContextEdmxViews.View0Accessed); Assert.True(PregenContextEdmxViews.View1Accessed); } }
/// <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; }
internal DbModificationCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target) : base(metadata, dataSpace) { DebugCheck.NotNull(target); _target = target; }
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); }
private CodeFirstCachedMetadataWorkspace(MetadataWorkspace metadataWorkspace, IEnumerable<Assembly> assemblies, DbProviderInfo providerInfo, string defaultContainerName) { _metadataWorkspace = metadataWorkspace; _assemblies = assemblies; _providerInfo = providerInfo; _defaultContainerName = defaultContainerName; }
/// <summary> /// Creates a new instance of perspective class so that query can work /// ignorant of all spaces /// </summary> /// <param name="metadataWorkspace">runtime metadata container</param> /// <param name="targetDataspace">target dataspace for the perspective</param> internal Perspective(MetadataWorkspace metadataWorkspace, DataSpace targetDataspace) { EntityUtil.CheckArgumentNull(metadataWorkspace, "metadataWorkspace"); m_metadataWorkspace = metadataWorkspace; m_targetDataspace = targetDataspace; }
private IEnumerable<KeyValuePair<Shaper<RecordState>, CoordinatorFactory<RecordState>>> GetNextResultShaperInfo( DbDataReader storeDataReader, MetadataWorkspace workspace, IEnumerable<ColumnMap> nextResultColumnMaps) { foreach (var nextResultColumnMap in nextResultColumnMaps) { yield return CreateShaperInfo(storeDataReader, nextResultColumnMap, workspace); } }
/// <summary> /// Initialize Metadata for an AssociationSet /// </summary> internal AssociationSetMetadata(Set<EntitySet> affectedTables, AssociationSet associationSet, MetadataWorkspace workspace) { // If there is only 1 table, there can be no ambiguity about the "destination" of a relationship, so such // sets are not typically required. var isRequired = 1 < affectedTables.Count; // determine the ends of the relationship var ends = associationSet.AssociationSetEnds; // find collocated entities foreach (var table in affectedTables) { // Find extents influencing the table var influencingExtents = MetadataHelper.GetInfluencingEntitySetsForTable(table, workspace); foreach (var influencingExtent in influencingExtents) { foreach (var end in ends) { // If the extent is an end of the relationship and we haven't already added it to the // required set... if (end.EntitySet.EdmEquals(influencingExtent)) { if (isRequired) { AddEnd(ref RequiredEnds, end.CorrespondingAssociationEndMember); } else if (null == RequiredEnds || !RequiredEnds.Contains(end.CorrespondingAssociationEndMember)) { AddEnd(ref OptionalEnds, end.CorrespondingAssociationEndMember); } } } } } // fix Required and Optional sets FixSet(ref RequiredEnds); FixSet(ref OptionalEnds); // for associations with referential constraints, the principal end is always interesting // since its key values may take precedence over the key values of the dependent end foreach (var constraint in associationSet.ElementType.ReferentialConstraints) { // FromRole is the principal end in the referential constraint var principalEnd = (AssociationEndMember)constraint.FromRole; if (!RequiredEnds.Contains(principalEnd) && !OptionalEnds.Contains(principalEnd)) { AddEnd(ref IncludedValueEnds, principalEnd); } } FixSet(ref IncludedValueEnds); }
/// <summary> /// Initializes a new instance of the <see cref="EntityTableDataLoader" /> class. /// </summary> /// <param name="connection"> The connection towards the database. </param> /// <param name="table"> The metadata of the table. </param> public EntityTableDataLoader(EntityConnection connection, TableDescription table) : base(table) { this.connection = connection; this.workspace = connection.GetMetadataWorkspace(); this.entitySet = MetadataWorkspaceHelper .GetEntityContainer(this.workspace) .GetEntitySetByName(table.Name, true); }
/// <summary> /// Creates a new instance of perspective class so that query can work /// ignorant of all spaces /// </summary> /// <param name="metadataWorkspace">runtime metadata container</param> /// <param name="targetDataspace">target dataspace for the perspective</param> internal Perspective( MetadataWorkspace metadataWorkspace, DataSpace targetDataspace) { //Contract.Requires(metadataWorkspace != null); m_metadataWorkspace = metadataWorkspace; m_targetDataspace = targetDataspace; }
/// <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 DbInsertCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, ReadOnlyModificationClauses setClauses, DbExpression returning) : base(metadata, dataSpace, target) { EntityUtil.CheckArgumentNull(setClauses, "setClauses"); // returning may be null this._setClauses = setClauses; this._returning = returning; }
// <summary> // Creates a new instance of perspective class so that query can work // ignorant of all spaces // </summary> // <param name="metadataWorkspace"> runtime metadata container </param> // <param name="targetDataspace"> target dataspace for the perspective </param> internal Perspective( MetadataWorkspace metadataWorkspace, DataSpace targetDataspace) { DebugCheck.NotNull(metadataWorkspace); _metadataWorkspace = metadataWorkspace; _targetDataspace = targetDataspace; }
internal RelPropertyHelper(MetadataWorkspace ws, HashSet<RelProperty> interestingRelProperties) { _relPropertyMap = new Dictionary<EntityTypeBase, List<RelProperty>>(); _interestingRelProperties = interestingRelProperties; foreach (var relationshipType in ws.GetItems<RelationshipType>(DataSpace.CSpace)) { ProcessRelationship(relationshipType); } }
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 DbMapping(DbContext context) { _context = context; var objectContext = ((IObjectContextAdapter)context).ObjectContext; _metadataWorkspace = objectContext.MetadataWorkspace; _codeFirstEntityContainer = _metadataWorkspace.GetEntityContainer("CodeFirstDatabase", DataSpace.SSpace); MapDb(); }
/// <summary> /// Initializes a new instance of the <see cref="DbInsertCommandTree"/> class. /// </summary> /// <param name="metadata">The model this command will operate on.</param> /// <param name="dataSpace">The data space.</param> /// <param name="target">The target table for the data manipulation language (DML) operation.</param> /// <param name="setClauses">The list of insert set clauses that define the insert operation. .</param> /// <param name="returning">A <see cref="DbExpression"/> that specifies a projection of results to be returned, based on the modified rows.</param> public DbInsertCommandTree( MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, ReadOnlyModificationClauses setClauses, DbExpression returning) : base(metadata, dataSpace, target) { DebugCheck.NotNull(setClauses); // returning may be null _setClauses = setClauses; _returning = returning; }
internal static EdmType GetAndCheckFunctionImportReturnType <TElement>( EdmFunction functionImport, int resultSetIndex, MetadataWorkspace workspace) { EdmType returnType; if (!MetadataHelper.TryGetFunctionImportReturnType <EdmType>(functionImport, resultSetIndex, out returnType)) { throw EntityUtil.ExecuteFunctionCalledWithNonReaderFunction(functionImport); } MetadataHelper.CheckFunctionImportReturnType <TElement>(returnType, workspace); return(returnType); }
private MetadataWorkspace CheckRetrieveMetadata(Type t) { MetadataWorkspace ret; lock (this.metadatas) { if (!this.metadatas.TryGetValue(t, out ret)) { ret = new MetadataWorkspace(this.GenerateEntityMetadataPaths(t), new Assembly[] { t.Assembly }); this.metadatas.Add(t, ret); } } return(ret); }
public static IDictionary <string, PropertyInfo> GetTableColumns(this MetadataWorkspace metadata, Type entityType) { var items = metadata.GetItems(DataSpace.CSSpace); var storageEntityType = metadata.GetItems(DataSpace.SSpace) .Where(x => x.BuiltInTypeKind == BuiltInTypeKind.EntityType).OfType <EntityType>() .Single(x => x.Name == entityType.Name); var columnNames = storageEntityType.Properties.ToDictionary(x => x.Name, y => y.MetadataProperties.FirstOrDefault(x => x.Name == "PreferredName")?.Value as string ?? y.Name); return(storageEntityType.Properties.Select((elm, index) => new { elm.Name, Property = entityType.GetProperty(columnNames[elm.Name]) }) .ToDictionary(x => x.Name, x => x.Property)); }
public bool ContainsQuery(MetadataWorkspace workspace, string sql) { Guard.NotNull(workspace, nameof(workspace)); Guard.NotEmpty(sql, nameof(sql)); HashSet <string> queries; if (_queries.TryGetValue(workspace, out queries)) { return(queries.Contains(sql)); } return(false); }
private static ModelMetadata GenerateModelMetadata(MetadataWorkspace ws) { var entityTypes = ws.GetItems <EntityType>(DataSpace.CSpace); var types = entityTypes.Select(x => x.GetClrType()); var constraints = entityTypes .SelectMany(et => et.NavigationProperties) .GroupBy(np => np.RelationshipType) .Select(r => r.ToList()) .Where(r => r.Count == 2) .SelectMany(r => GetConstraints(r[0], r[1])); return(new ModelMetadata(types, constraints)); }
internal ApiModelBuilder(string contextName, MetadataWorkspace dbMetadata) { this.contextName = contextName; this.dbMetadata = dbMetadata; ObjectItemCollection objectItemCollection = (ObjectItemCollection)dbMetadata.GetItemCollection(DataSpace.OSpace); this.dbEntityTypes = dbMetadata.GetItems <EntityType>(DataSpace.OSpace).ToDictionary( et => objectItemCollection.GetClrType(et)); this.entityTypeConfigs = new Dictionary <Type, ApiEntityTypeConfiguration>(); this.ignoredEntityTypes = null; }
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 _)); }
internal void SetDefaultContainer(string defaultContainerName) { EntityContainer container = null; if (!String.IsNullOrEmpty(defaultContainerName)) { if (!MetadataWorkspace.TryGetEntityContainer(defaultContainerName, DataSpace.CSpace, out container)) { throw new ArgumentException( Strings.ObjectContext_InvalidDefaultContainerName(defaultContainerName), "defaultContainerName"); } } _defaultContainer = container; }
private KeyValuePair <Shaper <RecordState>, CoordinatorFactory <RecordState> > CreateShaperInfo( DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace) { DebugCheck.NotNull(storeDataReader); DebugCheck.NotNull(columnMap); DebugCheck.NotNull(workspace); var shaperFactory = _translator.TranslateColumnMap <RecordState>(columnMap, workspace, null, MergeOption.NoTracking, streaming: true, valueLayer: true); var recordShaper = shaperFactory.Create( storeDataReader, null, workspace, MergeOption.NoTracking, readerOwned: true, streaming: true); return(new KeyValuePair <Shaper <RecordState>, CoordinatorFactory <RecordState> >( recordShaper, recordShaper.RootCoordinator.TypedCoordinatorFactory)); }
internal Shaper( DbDataReader reader, ObjectContext context, MetadataWorkspace workspace, MergeOption mergeOption, int stateCount, bool streaming) { Debug.Assert(context == null || workspace == context.MetadataWorkspace, "workspace must match context's workspace"); Reader = reader; MergeOption = mergeOption; State = new object[stateCount]; Context = context; Workspace = workspace; _spatialReader = new Lazy <DbSpatialDataReader>(CreateSpatialDataReader); Streaming = streaming; }
public void ImplicitLoadAssemblyForType_checks_only_calling_assembly_for_views_if_type_assembly_filtered_and_no_schema_attribute() { var mockCache = new Mock <IViewAssemblyCache>(); var workspace = new MetadataWorkspace( () => new EdmItemCollection(Enumerable.Empty <XmlReader>()), () => null, () => null, () => new ObjectItemCollection(mockCache.Object)); workspace.ImplicitLoadAssemblyForType(typeof(object), typeof(FactAttribute).Assembly); mockCache.Verify(m => m.CheckAssembly(typeof(object).Assembly, It.IsAny <bool>()), Times.Never()); mockCache.Verify(m => m.CheckAssembly(typeof(FactAttribute).Assembly, false), Times.Once()); }
private static ObjectContext GetObjectContext(string connectionString) { // You can use the metadata portion of the connection string the the designer added to your config for the paths var paths = new[] { "res://*/Northwind.csdl", "res://*/Northwind.ssdl", "res://*/Northwind.msl" }; var workspace = new MetadataWorkspace(paths, new[] { typeof(NorthwindEntities).Assembly }); var connection = new EntityConnection(workspace, new SqlConnection(connectionString)); return(new ObjectContext(connection)); }
public static string[] GetKeyNames(this DbContext context, Type entityType) { MetadataWorkspace metadata = ((IObjectContextAdapter)context).ObjectContext.MetadataWorkspace; // Get the mapping between CLR types and metadata OSpace ObjectItemCollection objectItemCollection = ((ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace)); // Get metadata for given CLR type EntityType entityMetadata = metadata .GetItems <EntityType>(DataSpace.OSpace) .Single(e => objectItemCollection.GetClrType(e) == entityType); return(entityMetadata.KeyProperties.Select(p => p.Name).ToArray()); }
internal static object GetSpatialValue( MetadataWorkspace workspace, DbDataReader reader, TypeUsage columnType, int columnOrdinal) { DbSpatialDataReader spatialDataReader = SpatialHelpers.CreateSpatialDataReader(workspace, reader); if (Helper.IsGeographicType((PrimitiveType)columnType.EdmType)) { return((object)spatialDataReader.GetGeography(columnOrdinal)); } return((object)spatialDataReader.GetGeometry(columnOrdinal)); }
/// <summary>A MetadataWorkspace extension method that gets entity type by type.</summary> /// <param name="metadataWorkspace">The metadataWorkspace to act on.</param> /// <param name="entityType">Type of the entity.</param> /// <returns>The entity type by type.</returns> /// not support class in generic class internal static EntityType GetEntityTypeByType(this MetadataWorkspace metadataWorkspace, Type entityType) { string name = entityType.FullName.Replace("+", "."); var lenght = name.IndexOf("`"); if (lenght != -1) { name = name.Substring(0, lenght); } return(metadataWorkspace .GetItems <EntityType>(DataSpace.OSpace) .SingleOrDefault(p => p.FullName == name)); }
internal static object GetSpatialValue(MetadataWorkspace workspace, DbDataReader reader, TypeUsage columnType, int columnOrdinal) { Debug.Assert(Helper.IsSpatialType(columnType)); var spatialReader = CreateSpatialDataReader(workspace, reader); if (Helper.IsGeographicType((PrimitiveType)columnType.EdmType)) { return(spatialReader.GetGeography(columnOrdinal)); } else { return(spatialReader.GetGeometry(columnOrdinal)); } }
/// <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 DebugCheck.NotNull(metadata); // Ensure that the data space value is valid if (!IsValidDataSpace(dataSpace)) { throw new ArgumentException(Strings.Cqt_CommandTree_InvalidDataSpace, "dataSpace"); } _metadata = metadata; _dataSpace = dataSpace; }
private MetadataWorkspace LoadFromFiles() { var sw = Stopwatch.StartNew(); var modelFilesPath = EntityFrameworkMapping.ModelFiles.Select(fileName => Path.Combine(_rhetosAppOptions.AssetsFolder, fileName)).ToList(); SetProviderManifestTokenIfNeeded(sw, modelFilesPath); var metadataWorkspace = new MetadataWorkspace(modelFilesPath, Array.Empty <Assembly>()); _performanceLogger.Write(sw, "Load EDM files."); return(metadataWorkspace); }
internal DbExpressionValidator(MetadataWorkspace metadata, DataSpace expectedDataSpace) : base(metadata) { requiredSpace = expectedDataSpace; allowedFunctionSpaces = new[] { DataSpace.CSpace, DataSpace.SSpace }; if (expectedDataSpace == DataSpace.SSpace) { allowedMetadataSpaces = new[] { DataSpace.SSpace, DataSpace.CSpace }; } else { allowedMetadataSpaces = new[] { DataSpace.CSpace }; } }
internal static DbSpatialDataReader CreateSpatialDataReader(MetadataWorkspace workspace, DbDataReader reader) { StoreItemCollection storeItemCollection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace); DbProviderFactory providerFactory = storeItemCollection.StoreProviderFactory; Debug.Assert(providerFactory != null, "GetProviderSpatialServices requires provider factory to have been initialized"); DbProviderServices providerServices = DbProviderServices.GetProviderServices(providerFactory); DbSpatialDataReader result = providerServices.GetSpatialDataReader(reader, storeItemCollection.StoreProviderManifestToken); Debug.Assert(result != null, "DbProviderServices did not throw ProviderIncompatibleException for null IDbSpatialDataReader"); return(result); }
public Repository(DbContext context, ConnectionFactory.ConnectionMethod conn, string connectionString = null, bool killConnectionOnCtxDispose = false, DbConnection changeLogConnectionContext = null) { _ChangeLogQueue = new List <ChangeLog_Entry>(); ContextChangesQueue = new List <ContextChange_DTO>(); KillConnectionOnDispose = killConnectionOnCtxDispose; ctx = context; ConnectionString = ctx.Database.Connection.ConnectionString; Workspace = ((IObjectContextAdapter)ctx).ObjectContext.MetadataWorkspace; LoadLogger(conn, connectionString, killConnectionOnCtxDispose, changeLogConnectionContext); }
private static string GetTableName(Type type, DbContext context) { MetadataWorkspace metadata = ((IObjectContextAdapter)context).ObjectContext.MetadataWorkspace; // Get the part of the model that contains info about the actual CLR types ObjectItemCollection objectItemCollection = (ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace); // Get the entity type from the model that maps to the CLR type EntityType entityType = metadata .GetItems <EntityType>(DataSpace.OSpace) .FirstOrDefault(e => objectItemCollection.GetClrType(e) == type); if (entityType == null) { return(null); } // Get the entity set that uses this entity type EntitySet entitySet = metadata .GetItems <EntityContainer>(DataSpace.CSpace) .Single() .EntitySets .FirstOrDefault(s => s.ElementType.Name == entityType.Name); if (entitySet == null) { return(null); } // Find the mapping between conceptual and storage model for this entity set EntitySetMapping mapping = metadata.GetItems <EntityContainerMapping>(DataSpace.CSSpace) .Single() .EntitySetMappings .Single(s => s.EntitySet == entitySet); if (mapping == null) { return(null); } // Find the storage entity set (table) that the entity is mapped EntitySet table = mapping .EntityTypeMappings.Single() .Fragments.Single() .StoreEntitySet; // Return the table name from the storage entity set return(string.Format("[{0}].[{1}]", table.Schema, (string)table.MetadataProperties["Table"].Value ?? table.Name)); }
private MetadataWorkspace CreateDrawingsAndSubdrawingsXmlMetadata() { EntityType drawingsType = new EntityType(); drawingsType.Name = "Drawings"; drawingsType.PrimaryKey.Add(new KeyMember("Id", 0)); drawingsType.Properties["Id"] = DataType.Integer; drawingsType.Properties["Title"] = DataType.String; drawingsType.Properties["Width"] = DataType.Integer; drawingsType.Properties["Height"] = DataType.Integer; drawingsType.Properties["BgColour"] = DataType.Integer; EntityType subDrawingsType = new EntityType(); subDrawingsType.Name = "SubDrawings"; subDrawingsType.PrimaryKey.Add(new KeyMember("MainDrawing", 0)); subDrawingsType.PrimaryKey.Add(new KeyMember("SubDrawing", 1)); subDrawingsType.PrimaryKey.Add(new KeyMember("X", 2)); subDrawingsType.PrimaryKey.Add(new KeyMember("Y", 3)); subDrawingsType.PrimaryKey.Add(new KeyMember("Z", 4)); subDrawingsType.Properties["MainDrawing"] = DataType.Integer; subDrawingsType.Properties["SubDrawing"] = DataType.Integer; subDrawingsType.Properties["X"] = DataType.Integer; subDrawingsType.Properties["Y"] = DataType.Integer; subDrawingsType.Properties["Z"] = DataType.Integer; Association subdrawingsMainToDrawings = new Association(); subdrawingsMainToDrawings.Name = "SubDrawings_Drawings_Main"; subdrawingsMainToDrawings.Principal = "Drawings"; subdrawingsMainToDrawings.Dependent = "SubDrawings"; subdrawingsMainToDrawings.PropertyMappings["Id"] = "MainDrawing"; Association subdrawingsSubsToDrawings = new Association(); subdrawingsSubsToDrawings.Name = "SubDrawings_Drawings_Sub"; subdrawingsSubsToDrawings.Principal = "Drawings"; subdrawingsSubsToDrawings.Dependent = "SubDrawings"; subdrawingsSubsToDrawings.PropertyMappings["Id"] = "SubDrawing"; MetadataWorkspace xmlMetadataWorkspace = new MetadataWorkspace(); xmlMetadataWorkspace.EntityTypes.Add(drawingsType); xmlMetadataWorkspace.EntityTypes.Add(subDrawingsType); xmlMetadataWorkspace.Associations.Add(subdrawingsMainToDrawings); xmlMetadataWorkspace.Associations.Add(subdrawingsSubsToDrawings); return(xmlMetadataWorkspace); }
/// <summary> /// Generate an Entity set for TEntity /// so that we can inspect the metadata /// </summary> /// <typeparam name="TEntity"></typeparam> /// <param name="dbCtx"></param> /// <returns></returns> private static EntitySet GetMetaDataEntitySet <TEntity>(DbContext dbCtx) { Type entityType = typeof(TEntity); string entityName = entityType.Name; MetadataWorkspace metaDataWS = ((IObjectContextAdapter)dbCtx).ObjectContext.MetadataWorkspace; //IEnumerable<EntitySet> entitySets; var entitySets = metaDataWS.GetItemCollection(DataSpace.SSpace) .GetItems <EntityContainer>() .Single() .BaseEntitySets .OfType <EntitySet>() .Where(entitySet => !entitySet.MetadataProperties.Contains("Type") || entitySet.MetadataProperties["Type"].ToString() == "Tables"); List <EntitySet> provisionedTables = entitySets.ToList(); EntitySet returnValue = provisionedTables.FirstOrDefault(t => t.Name == entityName); //When an Entity inherits a base class, the corresponding //table is sometimes named for the base class while (null == returnValue && null != entityType) { entityType = entityType.BaseType; entityName = entityType.Name; returnValue = provisionedTables.FirstOrDefault(t => t.Name == entityName); } return(returnValue); }
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)); }
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 EntityObject NewEntityFromOrig(MetadataWorkspace mdw) { var newEntity = Activator.CreateInstance(_detachedEntity.GetType()); var newEntityObj = (EntityObject)newEntity; newEntityObj.EntityKey = _entityKey; //use metadata and Reflection to populate entity var etype = newEntity.GetType(); foreach (var p in etype.GetProperties()) { //find the correct property in origvalues object origPropertyValue; if (_origValues.TryGetValue(p.Name, out origPropertyValue)) { p.SetValue(newEntity, origPropertyValue, null); } else { if (p.PropertyType.Name.StartsWith("EntityReference")) { //there is a "'1" in the propertytype.name var lastReference = p.Name.LastIndexOf("Reference"); var entName = p.Name.Remove(lastReference); var entitySetName = mdw.GetEntitySetName(entName); var eref = (EntityReference)(p.GetValue(newEntity, null)); //be sure that a deleted relationship is added before an added relationship foreach (var rel in _relationships) { if (rel.CurrentEndA.EntitySetName == entitySetName) { //this is the entitykey we want, //but we need to set entityreference.entitykey eref.EntityKey = rel.CurrentEndA; } else if (rel.CurrentEndB.EntitySetName == entitySetName) { eref.EntityKey = rel.CurrentEndB; } } //find entitykey } } } //after this, the calling code needs to attach to context, // then apply property changes using the detached entity return((EntityObject)newEntity); }
private static MetadataWorkspace GetProviderSchemaMetadataWorkspace( IDbDependencyResolver resolver, string providerInvariantName, SystemDataCommon.DbConnection providerConnection, Version targetSchemaVersion) { Debug.Assert(resolver != null, "resolver != null"); Debug.Assert(!string.IsNullOrWhiteSpace(providerInvariantName), "providerInvarianName cannot be null or empty"); Debug.Assert(providerConnection != null, "providerConnection != null"); Debug.Assert(EntityFrameworkVersion.IsValidVersion(targetSchemaVersion), "invalid targetSchemaVersion"); string csdlName; string ssdlName; string mslName; if (targetSchemaVersion >= EntityFrameworkVersion.Version3) { csdlName = DbProviderManifest.ConceptualSchemaDefinitionVersion3; ssdlName = DbProviderManifest.StoreSchemaDefinitionVersion3; mslName = DbProviderManifest.StoreSchemaMappingVersion3; } else { csdlName = DbProviderManifest.ConceptualSchemaDefinition; ssdlName = DbProviderManifest.StoreSchemaDefinition; mslName = DbProviderManifest.StoreSchemaMapping; } var providerServices = resolver.GetService <DbProviderServices>(providerInvariantName); Debug.Assert(providerServices != null, "Trying to get unregistered provider."); var providerManifest = providerServices.GetProviderManifest( providerServices.GetProviderManifestToken(providerConnection)); var edmItemCollection = LoadEdmItemCollection(csdlName); var storeItemCollection = LoadStoreItemCollection(providerManifest, ssdlName); var mappingItemCollection = LoadMappingItemCollection(providerManifest, mslName, edmItemCollection, storeItemCollection); var workspace = new MetadataWorkspace( () => edmItemCollection, () => storeItemCollection, () => mappingItemCollection); // TODO: there is currently no public surface to do this (workitem 606 on codeplex) //// make the views generate here so we can wrap the provider schema problems //// in a ProviderIncompatibleException //ForceViewGeneration(workspace); return(workspace); }
private static XDocument UpdateCSpaceOSpaceMappingCore(XDocument xDoc, MetadataWorkspace metadataWs) { var cspaceTypes = metadataWs.GetItems <System.Data.Entity.Core.Metadata.Edm.StructuralType>(DataSpace.CSpace); var tpls = cspaceTypes .Where(st => !(st is AssociationType)) .Select(st => { var ost = metadataWs.GetObjectSpaceType(st); return(new[] { st.FullName, ost.FullName }); }) .ToList(); var ocMapping = JsonConvert.SerializeObject(tpls); xDoc.Root.SetAttributeValue("CSpaceOSpaceMapping", ocMapping); return(xDoc); }
public virtual DbDataReader Create( DbDataReader storeDataReader, ColumnMap columnMap, MetadataWorkspace workspace, IEnumerable <ColumnMap> nextResultColumnMaps) { DebugCheck.NotNull(storeDataReader); DebugCheck.NotNull(columnMap); DebugCheck.NotNull(workspace); DebugCheck.NotNull(nextResultColumnMaps); var shaperInfo = CreateShaperInfo(storeDataReader, columnMap, workspace); DbDataReader result = new BridgeDataReader( shaperInfo.Key, shaperInfo.Value, /*depth:*/ 0, GetNextResultShaperInfo(storeDataReader, workspace, nextResultColumnMaps).GetEnumerator()); return(result); }