DataSpace

System\Data\Common\CommandTrees\DbCommandTree.cs (11)

40private readonly DataSpace _dataSpace; 47internal DbCommandTree(MetadataWorkspace metadata, DataSpace dataSpace) 67if (metadata.TryGetItemCollection(DataSpace.OSpace, out objectItemCollection)) 71effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSpace)); 72effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.CSSpace)); 73effectiveMetadata.RegisterItemCollection(metadata.GetItemCollection(DataSpace.SSpace)); 111internal DataSpace DataSpace { get { return _dataSpace; } } 190internal static bool IsValidDataSpace(DataSpace dataSpace) 192return (DataSpace.OSpace == dataSpace || 193DataSpace.CSpace == dataSpace || 194DataSpace.SSpace == dataSpace);

System\Data\Common\CommandTrees\DbDeleteCommandTree.cs (1)

27internal DbDeleteCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate)

System\Data\Common\CommandTrees\DbFunctionCommandTree.cs (1)

42/*CQT_PUBLIC_API(*/internal/*)*/ DbFunctionCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, EdmFunction edmFunction, TypeUsage resultType, IEnumerable<KeyValuePair<string, TypeUsage>> parameters)

System\Data\Common\CommandTrees\DbInsertCommandTree.cs (1)

33internal DbInsertCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, ReadOnlyModificationClauses setClauses, DbExpression returning)

System\Data\Common\CommandTrees\DbModificationCommandTree.cs (1)

29internal DbModificationCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target)

System\Data\Common\CommandTrees\DbQueryCommandTree.cs (3)

34DataSpace dataSpace, 61/*CQT_PUBLIC_API(*/internal/*)*/ DbQueryCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpression query) 102internal static DbQueryCommandTree FromValidExpression(MetadataWorkspace metadata, DataSpace dataSpace, DbExpression query)

System\Data\Common\CommandTrees\DbUpdateCommandTree.cs (1)

34internal DbUpdateCommandTree(MetadataWorkspace metadata, DataSpace dataSpace, DbExpressionBinding target, DbExpression predicate, ReadOnlyModificationClauses setClauses, DbExpression returning)

System\Data\Common\CommandTrees\ExpressionBuilder\Internal\ArgumentValidation.cs (3)

1952(BuiltInTypeKind.EdmFunction == item.BuiltInTypeKind && DataSpace.CSpace == item.DataSpace)) 1980return (item.DataSpace == DataSpace.SSpace || item.DataSpace == DataSpace.CSpace);

System\Data\Common\CommandTrees\Internal\ExpressionCopier.cs (1)

75if (DataSpace.SSpace == function.DataSpace)

System\Data\Common\CommandTrees\Internal\Validator.cs (14)

21private readonly DataSpace requiredSpace; 22private readonly DataSpace[] allowedMetadataSpaces; 23private readonly DataSpace[] allowedFunctionSpaces; 29internal DbExpressionValidator(MetadataWorkspace metadata, DataSpace expectedDataSpace) 33this.allowedFunctionSpaces = new[] { DataSpace.CSpace, DataSpace.SSpace }; 34if (expectedDataSpace == DataSpace.SSpace) 36this.allowedMetadataSpaces = new[] { DataSpace.SSpace, DataSpace.CSpace }; 40this.allowedMetadataSpaces = new[] { DataSpace.CSpace }; 141private TMetadata ValidateMetadata<TMetadata>(TMetadata metadata, Func<TMetadata, TMetadata> map, Func<TMetadata, DataSpace> getDataSpace, DataSpace[] allowedSpaces) 149DataSpace resultSpace = getDataSpace(result); 164ThrowInvalid(Strings.Cqt_Validator_InvalidIncorrectDataSpaceMetadata(typeof(TMetadata).Name, Enum.GetName(typeof(DataSpace), this.requiredSpace)));

System\Data\Common\CommandTrees\Internal\ViewSimplifier.cs (1)

112this.extent.EntityContainer.DataSpace != DataSpace.CSpace)

System\Data\Common\DbProviderServices.cs (2)

44StoreItemCollection storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); 95if (commandTree.DataSpace != DataSpace.SSpace)

System\Data\Common\DbXmlEnabledProviderManifest.cs (2)

118type.DataSpace = DataSpace.SSpace; 185: base(DataSpace.SSpace)

System\Data\Common\EntitySql\SemanticAnalyzer.cs (2)

889sr.TypeResolver.Perspective.MetadataWorkspace.GetItemCollection(DataSpace.CSSpace) as StorageMappingItemCollection; 1345Debug.Assert(memberModelTypeUsage.EdmType.DataSpace == DataSpace.CSpace, "member space must be CSpace");

System\Data\Common\EntityUtil.cs (4)

534static internal MetadataException InvalidCollectionForMapping(DataSpace space) { 558static internal InvalidOperationException ItemCollectionAlreadyRegistered(DataSpace space) { 561static internal InvalidOperationException NoCollectionForSpace(DataSpace space) { 564static internal InvalidOperationException InvalidCollectionSpecified(DataSpace space) {

System\Data\Common\Internal\Materialization\Shaper.cs (4)

299targetKey.EntityContainerName, DataSpace.CSpace); 411Debug.Assert(associationType.DataSpace == DataSpace.CSpace); 417oSpaceAssociation = this.Workspace.GetItemCollection(DataSpace.OSpace).GetItem<AssociationType>(associationType.FullName); 703DataSpace.CSpace);

System\Data\Common\Internal\Materialization\Util.cs (5)

22if (workspace.TryGetItemCollection(DataSpace.CSpace, out collection)) 24return (ObjectTypeMapping)workspace.GetMap(type, DataSpace.OCSpace); 33if (type.DataSpace == DataSpace.CSpace) 38ospaceType = workspace.GetMappedPrimitiveType(((PrimitiveType)type).PrimitiveTypeKind, DataSpace.OSpace); 44ospaceType = workspace.GetItem<EdmType>(type.FullName, DataSpace.OSpace);

System\Data\Common\Utils\CommandHelper.cs (2)

152StoreItemCollection storeItemCollection = (StoreItemCollection)connection.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace); 171if (!workspace.TryGetEntityContainer(containerName, DataSpace.CSpace, out entityContainer))

System\Data\Common\Utils\MetadataHelper.cs (6)

170ObjectItemCollection objectItemCollection = (ObjectItemCollection)workspace.GetItemCollection(DataSpace.OSpace); 175if (workspace.TryGetMap(objectEdmType, DataSpace.OCSpace, out map)) 328Debug.Assert(table.EntityContainer.GetDataSpace() == DataSpace.SSpace); 331workspace.TryGetItemCollection(DataSpace.CSSpace, out itemCollection); 352return GetTypeAndSubtypesOf(type, workspace.GetItemCollection(DataSpace.CSpace), includeAbstractTypes); 907Debug.Assert(sourceEntityType.DataSpace == DataSpace.OSpace && sourceEntityType.ClrType != null, "sourceEntityType must contain an ospace type");

System\Data\EntityClient\EntityCommand.cs (1)

612resultTree = new DbFunctionCommandTree(this.Connection.GetMetadataWorkspace(), DataSpace.CSpace, function, null, queryParams);

System\Data\EntityClient\EntityCommandDefinition.cs (2)

113DbFunctionCommandTree providerCommandTree = new DbFunctionCommandTree(entityCommandTree.MetadataWorkspace, DataSpace.SSpace, 243Debug.Assert(functionCommandTree.DataSpace == DataSpace.CSpace, "map from CSpace->SSpace function");

System\Data\EntityClient\EntityConnection.cs (9)

105if (!workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace)) 109if(!workspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)) 113if(!workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSSpace)) 129StoreItemCollection collection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace); 411(initializeAllCollections && !_metadataWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace))) 448edmItemCollection = (EdmItemCollection)_metadataWorkspace.GetItemCollection(DataSpace.CSpace); 451if (initializeAllCollections && !_metadataWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)) 947string edmCacheKey = CreateMetadataCacheKey(artifactLoader.GetOriginalPaths(DataSpace.CSpace), null, null); 969Debug.Assert(workspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace), "C-Space must be loaded before loading S or C-S space");

System\Data\EntityClient\EntityProviderServices.cs (2)

39StoreItemCollection storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace); 58if (commandTree.DataSpace != DataSpace.CSpace)

System\Data\EntityKey.cs (1)

388.GetEntityContainer(_entityContainerName, DataSpace.CSpace)

System\Data\EntityModel\SchemaObjectModel\RowTypeElement.cs (2)

108rowType.DataSpace = DataSpace.CSpace; 113rowType.DataSpace = DataSpace.SSpace;

System\Data\EntityModel\SchemaObjectModel\SchemaManager.cs (14)

201internal static bool TryGetSchemaVersion(XmlReader reader, out double version, out DataSpace dataSpace) 219dataSpace = default(DataSpace); 223internal static bool TryGetSchemaVersion(string xmlNamespaceName, out double version, out DataSpace dataSpace) 229dataSpace = DataSpace.CSpace; 233dataSpace = DataSpace.CSpace; 237dataSpace = DataSpace.CSpace; 241dataSpace = DataSpace.CSpace; 245dataSpace = DataSpace.SSpace; 249dataSpace = DataSpace.SSpace; 253dataSpace = DataSpace.SSpace; 257dataSpace = DataSpace.CSSpace; 261dataSpace = DataSpace.CSSpace; 265dataSpace = DataSpace.CSSpace; 269dataSpace = default(DataSpace);

System\Data\Mapping\DefaultObjectMappingItemCollection.cs (17)

36ObjectItemCollection objectCollection) : base(DataSpace.OCSpace) 61internal override Map GetMap(string identity, DataSpace typeSpace, bool ignoreCase) 79internal override bool TryGetMap(string identity, DataSpace typeSpace, bool ignoreCase, out Map map) 83if (typeSpace == DataSpace.CSpace) 111else if (typeSpace == DataSpace.OSpace) 159internal override Map GetMap(string identity, DataSpace typeSpace) 171internal override bool TryGetMap(string identity, DataSpace typeSpace, out Map map) 205DataSpace typeSpace = item.DataSpace; 240private Map GetOCMapForTransientType(EdmType edmType, DataSpace typeSpace) 242Debug.Assert(typeSpace == DataSpace.CSpace || typeSpace == DataSpace.OSpace || Helper.IsRowType(edmType) || Helper.IsCollectionType(edmType)); 246if (typeSpace != DataSpace.OSpace) 258else if (typeSpace == DataSpace.OSpace) 416objectMap.DataSpace = DataSpace.OCSpace; 505Debug.Assert(edmMember.DeclaringType.DataSpace == DataSpace.CSpace, "the cspace member is not on a cspace type"); 506Debug.Assert(objectMember.DeclaringType.DataSpace == DataSpace.OSpace, "the ospace member is not on a cspace type"); 834Debug.Assert(cspaceItem.DataSpace == DataSpace.CSpace, "ContainsMap: It must be a CSpace item");

System\Data\Mapping\MappingItemCollection.cs (5)

24internal MappingItemCollection(DataSpace dataSpace) : base(dataSpace) 35internal virtual bool TryGetMap(string identity, DataSpace typeSpace, out Map map) 70internal virtual Map GetMap(string identity, DataSpace typeSpace, bool ignoreCase) 84internal virtual bool TryGetMap(string identity, DataSpace typeSpace, bool ignoreCase, out Map map) 96internal virtual Map GetMap(string identity, DataSpace typeSpace)

System\Data\Mapping\StorageMappingItemCollection.cs (17)

81: base(DataSpace.CSSpace) 98readers = composite.CreateReaders(DataSpace.CSSpace); 101composite.GetPaths(DataSpace.CSSpace), true /*throwOnError*/); 123: base(DataSpace.CSSpace) 154: base(DataSpace.CSSpace) 179: base(DataSpace.CSSpace) 304internal override Map GetMap(string identity, DataSpace typeSpace, bool ignoreCase) 307if (typeSpace != DataSpace.CSpace) 322internal override bool TryGetMap(string identity, DataSpace typeSpace, bool ignoreCase, out Map map) 324if (typeSpace != DataSpace.CSpace) 337internal override Map GetMap(string identity, DataSpace typeSpace) 349internal override bool TryGetMap(string identity, DataSpace typeSpace, out Map map) 361DataSpace typeSpace = item.DataSpace; 362if (typeSpace != DataSpace.CSpace) 382DataSpace typeSpace = item.DataSpace; 383if (typeSpace != DataSpace.CSpace) 704storageMap.DataSpace = DataSpace.CSSpace;

System\Data\Mapping\StorageMappingItemCollection.ViewDictionary.cs (8)

83EntityContainer counterpartContainer = container.DataSpace == DataSpace.CSpace ? 347return GeneratedView.CreateGeneratedViewForFKAssociationSet(aSet, aSet.ElementType, new DbQueryCommandTree(workspace, DataSpace.SSpace, qView), storageMappingItemCollection, m_config); 357(extent.EntityContainer.DataSpace==DataSpace.SSpace)?"Table":"EntitySet",extent.Name)); 411workspace.GetItemCollection(DataSpace.CSSpace).GetItems<StorageEntityContainerMapping>(), out storageEntityContainerMapping)) 470var mappingCollection = (workspace.GetItemCollection(DataSpace.CSSpace) as StorageMappingItemCollection); 501if (!workspace.TryGetItem<EntityContainer>(entityContainerName, DataSpace.CSpace, out entityContainer)) 503workspace.TryGetItem<EntityContainer>(entityContainerName, DataSpace.SSpace, out entityContainer); 543if (!workspace.TryGetItemCollection(DataSpace.OSpace, out itemCollection))

System\Data\Mapping\StorageMappingItemLoader.cs (1)

3244if (conditionMember.DeclaringType.DataSpace == DataSpace.SSpace)

System\Data\Mapping\Update\Internal\UpdateCompiler.cs (3)

65DbDeleteCommandTree commandTree = new DbDeleteCommandTree(m_translator.MetadataWorkspace, DataSpace.SSpace, target, predicate); 128new DbUpdateCommandTree(m_translator.MetadataWorkspace, DataSpace.SSpace, target, predicate, setClauses.AsReadOnly(), returning); 160new DbInsertCommandTree(m_translator.MetadataWorkspace, DataSpace.SSpace, target, setClauses.AsReadOnly(), returning);

System\Data\Mapping\Update\Internal\UpdateTranslator.cs (1)

706DbFunctionCommandTree tree = new DbFunctionCommandTree(m_metadataWorkspace, DataSpace.SSpace,

System\Data\Mapping\ViewGeneration\GeneratedView.cs (1)

208Debug.Assert(m_extent.EntityContainer.DataSpace == DataSpace.CSpace, "Internal Tree should be asked only for query view");

System\Data\Mapping\ViewGeneration\Structures\LeafCellTreeNode.cs (1)

180if ((cellQuery.Extent.EntityContainer.DataSpace == DataSpace.SSpace)

System\Data\Mapping\ViewValidator.cs (1)

247if ((targetContainer.DataSpace != DataSpace.SSpace))

System\Data\Metadata\ClrPerspective.cs (7)

30: base(metadataWorkspace, DataSpace.CSpace) 67if (this.MetadataWorkspace.TryGetMap(type, DataSpace.OCSpace, out map)) 98if (this.MetadataWorkspace.TryGetMap(fullName, DataSpace.OSpace, ignoreCase, DataSpace.OCSpace, out map)) 104PrimitiveType primitiveType = this.MetadataWorkspace.GetMappedPrimitiveType(((PrimitiveType)map.EdmItem).PrimitiveTypeKind, DataSpace.CSpace); 112Debug.Assert(((GlobalItem)map.EdmItem).DataSpace == DataSpace.CSpace); 134if (!MetadataWorkspace.TryGetEntityContainer(defaultContainerName, DataSpace.CSpace, out container))

System\Data\Metadata\Converter.cs (8)

39dataSpace: DataSpace.CSpace); 55dataSpace: DataSpace.CSpace); 151if (convertedItemCache.ItemCollection.DataSpace == DataSpace.CSpace) 158Debug.Assert(convertedItemCache.ItemCollection.DataSpace == DataSpace.SSpace, "Did you add a new space?"); 1056DataSpace.CSpace); 1331private static DataSpace GetDataSpace(DbProviderManifest providerManifest) 1337return DataSpace.CSpace; 1341return DataSpace.SSpace;

System\Data\Metadata\Edm\AssociationType.cs (1)

35DataSpace dataSpace)

System\Data\Metadata\Edm\ComplexType.cs (2)

29internal ComplexType(string name, string namespaceName, DataSpace dataSpace) 111DataSpace.OSpace)

System\Data\Metadata\Edm\EdmFunction.cs (3)

24internal EdmFunction(string name, string namespaceName, DataSpace dataSpace, EdmFunctionPayload payload) 286return this.DataSpace == DataSpace.CSpace && !IsCachedStoreFunction && !IsFromProviderManifest && !IsFunctionImport; 450public DataSpace DataSpace;

System\Data\Metadata\Edm\EdmType.cs (2)

44DataSpace dataSpace) 258DataSpace dataSpace,

System\Data\Metadata\Edm\EntityContainer.cs (1)

31internal EntityContainer(string name, DataSpace dataSpace)

System\Data\Metadata\Edm\EntityType.cs (3)

35internal EntityType(string name, string namespaceName, DataSpace dataSpace) 49DataSpace dataSpace, 247DataSpace.OSpace)

System\Data\Metadata\Edm\EntityTypeBase.cs (1)

29internal EntityTypeBase(string name, string namespaceName, DataSpace dataSpace)

System\Data\Metadata\Edm\EnumType.cs (4)

62internal EnumType(string name, string namespaceName, PrimitiveType underlyingType, bool isFlags, DataSpace dataSpace) 67Debug.Assert(dataSpace == DataSpace.CSpace || dataSpace == DataSpace.OSpace, "Enums can be only defined in CSpace or OSpace."); 87base(clrType.Name, clrType.Namespace ?? string.Empty, DataSpace.OSpace)

System\Data\Metadata\Edm\GlobalItem.cs (4)

46[MetadataProperty(typeof(DataSpace), false)] 47internal DataSpace DataSpace 52Debug.Assert(GetDataSpace() != (DataSpace)(-1) || this.BuiltInTypeKind == BuiltInTypeKind.RowType || this.BuiltInTypeKind == BuiltInTypeKind.CollectionType, "DataSpace must have some valid value"); 59Debug.Assert(GetDataSpace() == (DataSpace)(-1) || GetDataSpace() == value || this.BuiltInTypeKind == BuiltInTypeKind.RowType || this.BuiltInTypeKind == BuiltInTypeKind.CollectionType, "Invalid Value being set for DataSpace");

System\Data\Metadata\Edm\ItemCollection.cs (3)

33internal ItemCollection(DataSpace dataspace) 41private readonly DataSpace _space; 51public DataSpace DataSpace

System\Data\Metadata\Edm\MetadataItem.cs (14)

198internal DataSpace GetDataSpace() 202default: return (DataSpace)(-1); 203case MetadataFlags.CSpace: return DataSpace.CSpace; 204case MetadataFlags.OSpace: return DataSpace.OSpace; 205case MetadataFlags.SSpace: return DataSpace.SSpace; 206case MetadataFlags.OCSpace: return DataSpace.OCSpace; 207case MetadataFlags.CSSpace: return DataSpace.CSSpace; 210internal void SetDataSpace(DataSpace space) 214private static MetadataFlags Convert(DataSpace space) { 218case DataSpace.CSpace: return MetadataFlags.CSpace; 219case DataSpace.OSpace: return MetadataFlags.OSpace; 220case DataSpace.SSpace: return MetadataFlags.SSpace; 221case DataSpace.OCSpace: return MetadataFlags.OCSpace; 222case DataSpace.CSSpace: return MetadataFlags.CSSpace;

System\Data\Metadata\Edm\MetadataItem_Static.cs (2)

496EdmType.Initialize(builtInType, name, EdmConstants.EdmNamespace, DataSpace.CSpace, isAbstract, baseType); 532DataSpace.CSpace,

System\Data\Metadata\Edm\PrimitiveType.cs (2)

45DataSpace dataSpace, 70DataSpace.OSpace, baseType, providerManifest)

System\Data\Metadata\Edm\Provider\ClrProviderManifest.cs (1)

185if (Helper.IsPrimitiveType(type) && ((PrimitiveType)type).DataSpace == DataSpace.OSpace)

System\Data\Metadata\Edm\Provider\EdmProviderManifest.cs (1)

217DataSpace.CSpace,

System\Data\Metadata\Edm\Provider\EdmProviderManifestFunctionBuilder.cs (2)

86DataSpace.CSpace, 167DataSpace.CSpace,

System\Data\Metadata\Edm\RelationshipType.cs (1)

35DataSpace dataSpace)

System\Data\Metadata\Edm\RowType.cs (1)

43: base(GetRowTypeIdentityFromProperties(CheckProperties(properties), initializerMetadata), EdmConstants.TransientNamespace, (DataSpace)(-1))

System\Data\Metadata\Edm\SimpleType.cs (1)

38internal SimpleType(string name, string namespaceName, DataSpace dataSpace)

System\Data\Metadata\Edm\StructuralType.cs (3)

40internal StructuralType(string name, string namespaceName, DataSpace dataSpace) 120else if (this.DataSpace != (DataSpace)(-1) && member.TypeUsage.EdmType.DataSpace != this.DataSpace) 122this.DataSpace = (DataSpace)(-1);

System\Data\Metadata\Edm\TypeUsage.cs (3)

405if (edmType.DataSpace == DataSpace.CSpace || edmType.DataSpace == DataSpace.OSpace) 432System.Diagnostics.Debug.Assert(((RefType)edmType).ElementType.DataSpace == DataSpace.CSpace);

System\Data\Metadata\EdmItemCollection.cs (8)

46: base(DataSpace.CSpace) 67: base(DataSpace.CSpace) 80: base(DataSpace.CSpace) 90: base(DataSpace.CSpace) 114: base(DataSpace.CSpace) 126readers = composite.CreateReaders(DataSpace.CSpace); 128composite.GetPaths(DataSpace.CSpace), 318if (globalItem.BuiltInTypeKind == BuiltInTypeKind.EdmFunction && globalItem.DataSpace == DataSpace.SSpace)

System\Data\Metadata\EdmValidator.cs (1)

280item.DataSpace != DataSpace.OSpace && string.Empty == item.NamespaceName)

System\Data\Metadata\MetadataArtifactLoader.cs (8)

35public abstract void CollectFilePermissionPaths(List<string> paths, DataSpace spaceToGet); 250public virtual List<string> GetOriginalPaths(DataSpace spaceToGet) 278public abstract List<string> GetPaths(DataSpace spaceToGet); 295public abstract List<XmlReader> CreateReaders(DataSpace spaceToGet); 406protected static bool IsArtifactOfDataSpace(string resource, DataSpace dataSpace) 408if (dataSpace == DataSpace.CSpace) 411if (dataSpace == DataSpace.SSpace) 414if (dataSpace == DataSpace.CSSpace)

System\Data\Metadata\MetadataArtifactLoaderComposite.cs (4)

55public override void CollectFilePermissionPaths(List<string> paths, DataSpace spaceToGet) 93public override List<string> GetOriginalPaths(DataSpace spaceToGet) 110public override List<string> GetPaths(DataSpace spaceToGet) 159public override List<XmlReader> CreateReaders(DataSpace spaceToGet)

System\Data\Metadata\MetadataArtifactLoaderCompositeFile.cs (8)

60public override void CollectFilePermissionPaths(List<string> paths, DataSpace spaceToGet) 140public override List<string> GetOriginalPaths(DataSpace spaceToGet) 150public override List<string> GetPaths(DataSpace spaceToGet) 168private bool TryGetListForSpace(DataSpace spaceToGet, out IList<MetadataArtifactLoaderFile> files) 172case DataSpace.CSpace: 175case DataSpace.SSpace: 178case DataSpace.CSSpace: 241public override List<XmlReader> CreateReaders(DataSpace spaceToGet)

System\Data\Metadata\MetadataArtifactLoaderCompositeResource.cs (4)

65public override void CollectFilePermissionPaths(List<string> paths, DataSpace spaceToGet) 81public override List<string> GetOriginalPaths(DataSpace spaceToGet) 91public override List<string> GetPaths(DataSpace spaceToGet) 140public override List<XmlReader> CreateReaders(DataSpace spaceToGet)

System\Data\Metadata\MetadataArtifactLoaderFile.cs (3)

103public override void CollectFilePermissionPaths(List<string> paths, DataSpace spaceToGet) 115public override List<string> GetPaths(DataSpace spaceToGet) 164public override List<XmlReader> CreateReaders(DataSpace spaceToGet)

System\Data\Metadata\MetadataArtifactLoaderResource.cs (3)

98public override void CollectFilePermissionPaths(List<string> paths, DataSpace spaceToGet) 108public override List<string> GetPaths(DataSpace spaceToGet) 178public override List<XmlReader> CreateReaders(DataSpace spaceToGet)

System\Data\Metadata\MetadataArtifactLoaderXmlReaderWrapper.cs (3)

100public override void CollectFilePermissionPaths(List<string> paths, DataSpace spaceToGet) 110public override List<string> GetPaths(DataSpace spaceToGet) 152public override List<XmlReader> CreateReaders(DataSpace spaceToGet)

System\Data\Metadata\MetadataCache.cs (11)

638List<XmlReader> readers = loader.CreateReaders(DataSpace.CSpace); 643loader.GetPaths(DataSpace.CSpace) 647loader.CollectFilePermissionPaths(permissionPaths, DataSpace.CSpace); 698IEnumerable<XmlReader> sSpaceXmlReaders = loader.CreateReaders(DataSpace.SSpace); 704loader.GetPaths(DataSpace.SSpace)); 726IEnumerable<XmlReader> csSpaceXmlReaders = loader.CreateReaders(DataSpace.CSSpace); 733loader.GetPaths(DataSpace.CSSpace)); 741loader.CollectFilePermissionPaths(permissionPaths, DataSpace.SSpace); 742loader.CollectFilePermissionPaths(permissionPaths, DataSpace.CSSpace); 855if ((loader.GetPaths(DataSpace.SSpace) == null) || (loader.GetPaths(DataSpace.SSpace).Count == 0))

System\Data\Metadata\MetadataWorkspace.cs (71)

System\Data\Metadata\ModelPerspective.cs (1)

27: base(metadataWorkspace, DataSpace.CSpace)

System\Data\Metadata\ObjectHelper.cs (5)

145Debug.Assert(edmProperty.TypeUsage.EdmType.DataSpace == DataSpace.CSpace, "cspace property must have a cspace type"); 146Debug.Assert(columnProperty.TypeUsage.EdmType.DataSpace == DataSpace.SSpace, "sspace type usage must have a sspace type"); 173if (sspaceType.EdmType.DataSpace == DataSpace.SSpace) 206Debug.Assert(cspaceType.EdmType.DataSpace == DataSpace.CSpace, "cspace property must have a cspace type"); 207Debug.Assert(storeType.EdmType.DataSpace == DataSpace.CSpace, "storeType type usage must have a sspace type");

System\Data\Metadata\ObjectItemCollection.cs (4)

32: base(DataSpace.OSpace) 525if (objectSpaceType.DataSpace != DataSpace.OSpace) 575Debug.Assert(DataSpace.CSpace == cspaceType.DataSpace, "DataSpace should be CSpace"); 595Debug.Assert(DataSpace.OSpace == edmType.DataSpace, "DataSpace must be OSpace");

System\Data\Metadata\ObjectLayer\ObjectItemAttributeAssemblyLoader.cs (1)

230AssociationType associationType = new AssociationType(roleAttribute.RelationshipName, roleAttribute.RelationshipNamespaceName, roleAttribute.IsForeignKey, DataSpace.OSpace);

System\Data\Metadata\ObjectLayer\ObjectItemConventionAssemblyLoader.cs (1)

698AssociationType ospaceAssociation = new AssociationType(cspaceAssociation.Name, cspaceAssociation.NamespaceName, cspaceAssociation.IsForeignKey, DataSpace.OSpace);

System\Data\Metadata\Perspective.cs (7)

29DataSpace targetDataspace) 40private DataSpace m_targetDataspace; 155m_targetDataspace == DataSpace.SSpace ? 159if (m_targetDataspace == DataSpace.CSpace) 179if (m_metadataWorkspace.TryGetItemCollection(DataSpace.SSpace, out storeItemCollection)) 209primitiveType = m_metadataWorkspace.GetMappedPrimitiveType(primitiveTypeKind, DataSpace.CSpace); 220internal DataSpace TargetDataspace

System\Data\Metadata\StoreItemCollection.cs (9)

53: base(DataSpace.SSpace) 78: base(DataSpace.SSpace) 105: base(DataSpace.SSpace) 123: base(DataSpace.SSpace) 149: base(DataSpace.SSpace) 163readers = composite.CreateReaders(DataSpace.SSpace); 168composite.GetPaths(DataSpace.SSpace), true, 366Debug.Assert(sTypeFunction.DataSpace == Edm.DataSpace.SSpace, "sTypeFunction.DataSpace == Edm.DataSpace.SSpace"); 403DataSpace.CSpace,

System\Data\Metadata\TargetPerspective.cs (2)

34internal const DataSpace TargetPerspectiveDataSpace = DataSpace.SSpace;

System\Data\Metadata\TypeHelpers.cs (2)

53if (pType.DataSpace != DataSpace.CSpace) 841bool isCanonicalFunction = (function.DataSpace == DataSpace.CSpace && function.NamespaceName == EdmConstants.EdmNamespace);

System\Data\Objects\DataClasses\RelatedEnd.cs (2)

2424relationshipType = context.MetadataWorkspace.GetItem<EdmType>(_navigation.RelationshipName, DataSpace.CSpace); 2553EntityType entityType = _wrappedOwner.Context.MetadataWorkspace.GetItem<EntityType>(_wrappedOwner.IdentityType.FullName, DataSpace.OSpace);

System\Data\Objects\DataClasses\RelationshipManager.cs (6)

379EntityType entityType = wrappedOwner.Context.MetadataWorkspace.GetItem<EntityType>(wrappedOwner.IdentityType.FullName, DataSpace.OSpace); 493Debug.Assert(sourceEntityType.DataSpace == DataSpace.OSpace && sourceEntityType.ClrType != null, "sourceEntityType must contain an ospace type"); 656return (ObjectItemCollection)wrappedOwner.Context.MetadataWorkspace.GetItemCollection(DataSpace.OSpace); 669mappings.TryGetMap(WrappedOwner.IdentityType.FullName, DataSpace.OSpace, out map)) 690collection = (DefaultObjectMappingItemCollection)wrappedOwner.Context.MetadataWorkspace.GetItemCollection(DataSpace.OCSpace); 827ownerKey.EntityContainerName, DataSpace.CSpace);

System\Data\Objects\ELinq\CompiledELinqQueryState.cs (2)

83DbQueryCommandTree tree = DbQueryCommandTree.FromValidExpression(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression); 113DbQueryCommandTree tree = DbQueryCommandTree.FromValidExpression(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression);

System\Data\Objects\ELinq\ELinqQueryState.cs (1)

191DbQueryCommandTree tree = DbQueryCommandTree.FromValidExpression(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression);

System\Data\Objects\ELinq\ExpressionConverter.cs (2)

207return (EdmItemCollection)_funcletizer.RootContext.MetadataWorkspace.GetItemCollection(DataSpace.CSpace, true); 214return ((StoreItemCollection)_funcletizer.RootContext.MetadataWorkspace.GetItemCollection(DataSpace.SSpace)).StoreProviderManifest;

System\Data\Objects\Internal\EntityProxyFactory.cs (1)

155Debug.Assert(ospaceEntityType.DataSpace == DataSpace.OSpace, "ospaceEntityType.DataSpace must be OSpace");

System\Data\Objects\Internal\EntitySqlQueryState.cs (1)

195DbQueryCommandTree tree = DbQueryCommandTree.FromValidExpression(this.ObjectContext.MetadataWorkspace, DataSpace.CSpace, queryExpression);

System\Data\Objects\Internal\LazyLoadBehavior.cs (1)

117Debug.Assert(ospaceEntityType.DataSpace == DataSpace.OSpace, "ospaceEntityType.DataSpace must be OSpace");

System\Data\Objects\Internal\ObjectFullSpanRewriter.cs (1)

200AssociationType relationship = this.Metadata.GetItem<AssociationType>(property.RelationshipType.FullName, DataSpace.CSpace);

System\Data\Objects\Internal\ObjectSpanRewriter.cs (1)

605foreach (AssociationType association in _tree.MetadataWorkspace.GetItems<AssociationType>(DataSpace.CSpace))

System\Data\Objects\ObjectContext.cs (17)

260if (!_workspace.IsItemCollectionAlreadyRegistered(DataSpace.OSpace)) 267_workspace.GetItemCollection(DataSpace.OCSpace); 1293System.Collections.ObjectModel.ReadOnlyCollection<EntityContainer> entityContainers = this.MetadataWorkspace.GetItems<EntityContainer>(DataSpace.CSpace); 1588if (!MetadataWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace)) 1590Debug.Assert(!MetadataWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.CSSpace), "ObjectContext has C-S metadata but not S?"); 1600Debug.Assert(connectionWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.CSpace) && 1601connectionWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.SSpace) && 1602connectionWorkspace.IsItemCollectionAlreadyRegistered(DataSpace.CSSpace), 1608ItemCollection connectionCSpaceCollection = connectionWorkspace.GetItemCollection(DataSpace.CSpace); 1609ItemCollection contextCSpaceCollection = MetadataWorkspace.GetItemCollection(DataSpace.CSpace); 1614MetadataWorkspace.RegisterItemCollection(connectionWorkspace.GetItemCollection(DataSpace.SSpace)); 1615MetadataWorkspace.RegisterItemCollection(connectionWorkspace.GetItemCollection(DataSpace.CSSpace)); 1847if (!this.MetadataWorkspace.TryGetEntityContainer(entityContainerName, DataSpace.CSpace, out container)) 2230DbQueryCommandTree tree = DbQueryCommandTree.FromValidExpression(this.MetadataWorkspace, DataSpace.CSpace, refreshQuery); 2890ObjectItemCollection ospaceItems = (ObjectItemCollection)MetadataWorkspace.GetItemCollection(DataSpace.OSpace); 2963ClrEntityType entityType = MetadataWorkspace.GetItem<ClrEntityType>(clrType.FullName, DataSpace.OSpace); 3308return (StoreItemCollection)entityConnection.GetMetadataWorkspace().GetItemCollection(DataSpace.SSpace);

System\Data\Objects\ObjectQuery_EntitySqlExtensions.cs (1)

369if (!this.QueryState.ObjectContext.MetadataWorkspace.GetItemCollection(DataSpace.OSpace).TryGetType(clrOfType.Name, clrOfType.Namespace ?? string.Empty, out ofType) ||

System\Data\Objects\ObjectStateManager.cs (4)

313var entityType = MetadataWorkspace.GetItem<ClrEntityType>(identityType.FullName, DataSpace.OSpace); 2984MetadataWorkspace.GetMap(entityType.FullName, DataSpace.OSpace, DataSpace.OCSpace)); 3004MetadataWorkspace.GetMap(edmType, DataSpace.OCSpace));

System\Data\Objects\ObjectViewFactory.cs (2)

269if (typeUsage.EdmType.DataSpace == DataSpace.OSpace) 275Debug.Assert(typeUsage.EdmType.DataSpace == DataSpace.CSpace, String.Format(System.Globalization.CultureInfo.InvariantCulture, "Expected EdmType.DataSpace to be C-Space, but instead it is {0}.", typeUsage.EdmType.DataSpace.ToString()));

System\Data\Query\InternalTrees\ColumnMapFactory.cs (1)

194(EdmItemCollection)workspace.GetItemCollection(DataSpace.CSpace), init, members);

System\Data\Query\InternalTrees\RelPropertyHelper.cs (1)

180foreach (RelationshipType relationshipType in ws.GetItems<RelationshipType>(DataSpace.CSpace))

System\Data\Query\PlanCompiler\CTreeGenerator.cs (1)

359_queryTree = DbQueryCommandTree.FromValidExpression(itree.MetadataWorkspace, DataSpace.SSpace, queryExpression);

System\Data\Query\PlanCompiler\JoinElimination.cs (1)

144var sspace = (StoreItemCollection)m_compilerState.MetadataWorkspace.GetItemCollection(Metadata.Edm.DataSpace.SSpace);

System\Data\Query\PlanCompiler\PreProcessor.cs (2)

310PlanCompiler.Assert(entitySet.EntityContainer.DataSpace == DataSpace.CSpace, "Store entity sets cannot have Query Mapping Views and should not be used with ExpandView"); 2119if (scanTableOp.Table.TableMetadata.Extent.EntityContainer.DataSpace == DataSpace.SSpace)

System\Data\Spatial\SpatialHelpers.cs (1)

33StoreItemCollection storeItemCollection = (StoreItemCollection)workspace.GetItemCollection(DataSpace.SSpace);

System\Data\SqlClient\SqlGen\SqlGenerator.cs (2)

511_storeItemCollection = (StoreItemCollection)this.Workspace.GetItemCollection(DataSpace.SSpace); 3816Debug.Assert(type.EdmType.DataSpace == DataSpace.CSpace, "Type must be in cSpace");

System\Data\SqlClient\SqlProviderServices.cs (1)

72StoreItemCollection storeMetadata = (StoreItemCollection)commandTree.MetadataWorkspace.GetItemCollection(DataSpace.SSpace);