internal override void Validate() { if (this._isAlreadyValidated) { return; } base.Validate(); if (this.ExtendingEntityContainer != null) { this.ExtendingEntityContainer.Validate(); foreach (SchemaElement member in this.ExtendingEntityContainer.Members) { AddErrorKind error = this.Members.TryAdd(member.Clone((SchemaElement)this)); this.DuplicateOrEquivalentMemberNameWhileExtendingEntityContainer(member, error); } } HashSet <string> tableKeys = new HashSet <string>(); foreach (SchemaElement member in this.Members) { EntityContainerEntitySet entitySet = member as EntityContainerEntitySet; if (entitySet != null && this.Schema.DataModel == SchemaDataModelOption.ProviderDataModel) { this.CheckForDuplicateTableMapping(tableKeys, entitySet); } member.Validate(); } this.ValidateRelationshipSetHaveUniqueEnds(); this.ValidateOnlyBaseEntitySetTypeDefinesConcurrency(); this._isAlreadyValidated = true; }
private IRelationshipEnd InferRelationshipEnd(EntityContainerEntitySet set) { if (this.ParentElement.Relationship == null) { return((IRelationshipEnd)null); } List <IRelationshipEnd> relationshipEndList = new List <IRelationshipEnd>(); foreach (IRelationshipEnd end in (IEnumerable <IRelationshipEnd>) this.ParentElement.Relationship.Ends) { if (set.EntityType.IsOfType((StructuredType)end.Type)) { relationshipEndList.Add(end); } } if (relationshipEndList.Count == 1) { return(relationshipEndList[0]); } if (relationshipEndList.Count == 0) { this.AddError(ErrorCode.FailedInference, EdmSchemaErrorSeverity.Error, (object)Strings.InferRelationshipEndFailedNoEntitySetMatch((object)set.Name, (object)this.ParentElement.Name, (object)this.ParentElement.Relationship.FQName, (object)set.EntityType.FQName, (object)this.ParentElement.ParentElement.FQName)); } else { this.AddError(ErrorCode.FailedInference, EdmSchemaErrorSeverity.Error, (object)Strings.InferRelationshipEndAmbiguous((object)set.Name, (object)this.ParentElement.Name, (object)this.ParentElement.Relationship.FQName, (object)set.EntityType.FQName, (object)this.ParentElement.ParentElement.FQName)); } return((IRelationshipEnd)null); }
private void HandleEntitySetElement(XmlReader reader) { EntityContainerEntitySet containerEntitySet = new EntityContainerEntitySet(this); containerEntitySet.Parse(reader); this.Members.Add((SchemaElement)containerEntitySet, true, new Func <object, string>(Strings.DuplicateEntityContainerMemberName)); }
private void HandleEntitySetElement(XmlReader reader) { DebugCheck.NotNull(reader); var set = new EntityContainerEntitySet(this); set.Parse(reader); Members.Add(set, true, Strings.DuplicateEntityContainerMemberName); }
internal override SchemaElement Clone(SchemaElement parentElement) { EntityContainerEntitySet containerEntitySet = new EntityContainerEntitySet((EntityContainer)parentElement); containerEntitySet._definingQueryElement = this._definingQueryElement; containerEntitySet._entityType = this._entityType; containerEntitySet._schema = this._schema; containerEntitySet._table = this._table; containerEntitySet.Name = this.Name; return((SchemaElement)containerEntitySet); }
/// <summary> /// Adds a child EntitySet's tableKey (Schema/Table combination) to the validation collection /// This is used to validate that no child EntitySets share a Schema.Table combination /// </summary> private void CheckForDuplicateTableMapping(HashSet <string> tableKeys, EntityContainerEntitySet entitySet) { string schema; string table; if (String.IsNullOrEmpty(entitySet.DbSchema)) { // if there is no specified DbSchema, use the parent EntityContainer's name schema = Name; } else { schema = entitySet.DbSchema; } if (String.IsNullOrEmpty(entitySet.Table)) { // if there is no specified Table, use the EntitySet's name table = entitySet.Name; } else { table = entitySet.Table; } // create a key using the DbSchema and Table var tableKey = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", schema, table); if (entitySet.DefiningQuery != null) { // don't consider the schema name for defining queries, because // we can't say for sure that it is the same as the entity container // so in this example // // <EntityContainer Name="dbo"> // <EntitySet Name="ByVal"> // <DefiningQuery>Select col1 from dbi.ByVal</DefiningQuery> // </EntitySet> // <EntitySet Name="ByVal1" Table="ByVal"/> // ... // // ByVal and ByVal1 should not conflict in our check tableKey = entitySet.Name; } var alreadyExisted = !tableKeys.Add(tableKey); if (alreadyExisted) { entitySet.AddError( ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error, Strings.DuplicateEntitySetTable(entitySet.Name, schema, table)); } }
internal override SchemaElement Clone(SchemaElement parentElement) { var entitySet = new EntityContainerEntitySet((EntityContainer)parentElement); entitySet._definingQueryElement = _definingQueryElement; entitySet._entityType = _entityType; entitySet._schema = _schema; entitySet._table = _table; entitySet.Name = Name; return(entitySet); }
private void ValidateFunctionImportReturnType( SchemaElement owner, SchemaType returnType, CollectionKind returnTypeCollectionKind, EntityContainerEntitySet entitySet, bool entitySetPathDefined) { if (returnType != null && !this.ReturnTypeMeetsFunctionImportBasicRequirements(returnType, returnTypeCollectionKind)) { owner.AddError(ErrorCode.FunctionImportUnsupportedReturnType, EdmSchemaErrorSeverity.Error, owner, (object)this.GetReturnTypeErrorMessage(this.Name)); } this.ValidateFunctionImportReturnType(owner, returnType, entitySet, entitySetPathDefined); }
private void InferEnds() { foreach (IRelationshipEnd end in (IEnumerable <IRelationshipEnd>) this.Relationship.Ends) { if (!this.HasEnd(end.Name)) { EntityContainerEntitySet entitySet = this.InferEntitySet(end); if (entitySet != null) { this.AddEnd(end, entitySet); } } } }
internal override void ResolveTopLevelNames() { base.ResolveTopLevelNames(); if (this._entitySet != null) { return; } this._entitySet = this.ParentElement.ParentElement.FindEntitySet(this._unresolvedEntitySetName); if (this._entitySet != null) { return; } this.AddError(ErrorCode.InvalidEndEntitySet, EdmSchemaErrorSeverity.Error, (object)Strings.InvalidEntitySetNameReference((object)this._unresolvedEntitySetName, (object)this.Name)); }
protected override void AddEnd( IRelationshipEnd relationshipEnd, EntityContainerEntitySet entitySet) { EntityContainerAssociationSetEnd associationSetEnd = new EntityContainerAssociationSetEnd(this); associationSetEnd.Role = relationshipEnd.Name; associationSetEnd.RelationshipEnd = relationshipEnd; associationSetEnd.EntitySet = entitySet; if (associationSetEnd.EntitySet == null) { return; } this._relationshipEnds.Add(associationSetEnd.Role, associationSetEnd); }
// <summary> // Used during the resolve phase to resolve the type name to the object that represents that type // </summary> internal override void ResolveTopLevelNames() { base.ResolveTopLevelNames(); if (_entitySet == null) { _entitySet = ParentElement.ParentElement.FindEntitySet(_unresolvedEntitySetName); if (_entitySet == null) { AddError( ErrorCode.InvalidEndEntitySet, EdmSchemaErrorSeverity.Error, Strings.InvalidEntitySetNameReference(_unresolvedEntitySetName, Name)); } } }
private void ValidateFunctionImportReturnType( SchemaElement owner, SchemaType returnType, EntityContainerEntitySet entitySet, bool entitySetPathDefined) { SchemaEntityType schemaEntityType = returnType as SchemaEntityType; if (entitySet != null && entitySetPathDefined) { owner.AddError(ErrorCode.FunctionImportEntitySetAndEntitySetPathDeclared, EdmSchemaErrorSeverity.Error, (object)Strings.FunctionImportEntitySetAndEntitySetPathDeclared((object)this.FQName)); } if (schemaEntityType != null) { if (entitySet == null) { owner.AddError(ErrorCode.FunctionImportReturnsEntitiesButDoesNotSpecifyEntitySet, EdmSchemaErrorSeverity.Error, (object)Strings.FunctionImportReturnEntitiesButDoesNotSpecifyEntitySet((object)this.FQName)); } else { if (entitySet.EntityType == null || schemaEntityType.IsOfType((StructuredType)entitySet.EntityType)) { return; } owner.AddError(ErrorCode.FunctionImportEntityTypeDoesNotMatchEntitySet, EdmSchemaErrorSeverity.Error, (object)Strings.FunctionImportEntityTypeDoesNotMatchEntitySet((object)this.FQName, (object)entitySet.EntityType.FQName, (object)entitySet.Name)); } } else { SchemaComplexType schemaComplexType = returnType as SchemaComplexType; if (schemaComplexType != null) { if (entitySet == null && !entitySetPathDefined) { return; } owner.AddError(ErrorCode.ComplexTypeAsReturnTypeAndDefinedEntitySet, EdmSchemaErrorSeverity.Error, owner.LineNumber, owner.LinePosition, (object)Strings.ComplexTypeAsReturnTypeAndDefinedEntitySet((object)this.FQName, (object)schemaComplexType.Name)); } else { if (entitySet == null && !entitySetPathDefined) { return; } owner.AddError(ErrorCode.FunctionImportSpecifiesEntitySetButDoesNotReturnEntityType, EdmSchemaErrorSeverity.Error, (object)Strings.FunctionImportSpecifiesEntitySetButNotEntityType((object)this.FQName)); } } }
internal void ResolveEntitySet( SchemaElement owner, string unresolvedEntitySet, ref EntityContainerEntitySet entitySet) { if (entitySet != null || unresolvedEntitySet == null) { return; } entitySet = this._container.FindEntitySet(unresolvedEntitySet); if (entitySet != null) { return; } owner.AddError(ErrorCode.FunctionImportUnknownEntitySet, EdmSchemaErrorSeverity.Error, (object)Strings.FunctionImportUnknownEntitySet((object)unresolvedEntitySet, (object)this.FQName)); }
// <summary> // Create and add a EntityContainerEnd from the IRelationshipEnd provided // </summary> // <param name="relationshipEnd"> The relationship end of the end to add. </param> // <param name="entitySet"> The entitySet to associate with the relationship end. </param> protected override void AddEnd(IRelationshipEnd relationshipEnd, EntityContainerEntitySet entitySet) { DebugCheck.NotNull(relationshipEnd); Debug.Assert(!_relationshipEnds.ContainsKey(relationshipEnd.Name)); // we expect set to be null sometimes var end = new EntityContainerAssociationSetEnd(this); end.Role = relationshipEnd.Name; end.RelationshipEnd = relationshipEnd; end.EntitySet = entitySet; if (end.EntitySet != null) { _relationshipEnds.Add(end.Role, end); } }
private void CheckForDuplicateTableMapping( HashSet <string> tableKeys, EntityContainerEntitySet entitySet) { string str1 = !string.IsNullOrEmpty(entitySet.DbSchema) ? entitySet.DbSchema : this.Name; string str2 = !string.IsNullOrEmpty(entitySet.Table) ? entitySet.Table : entitySet.Name; string str3 = string.Format((IFormatProvider)CultureInfo.InvariantCulture, "{0}.{1}", (object)str1, (object)str2); if (entitySet.DefiningQuery != null) { str3 = entitySet.Name; } if (tableKeys.Add(str3)) { return; } entitySet.AddError(ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error, (object)Strings.DuplicateEntitySetTable((object)entitySet.Name, (object)str1, (object)str2)); }
/// <summary> /// If the role name is missing but an entity set is given, figure out what the /// relationship end should be /// </summary> /// <param name="set"> The given EntitySet </param> /// <returns> The appropriate relationship end </returns> private IRelationshipEnd InferRelationshipEnd(EntityContainerEntitySet set) { DebugCheck.NotNull(set); if (ParentElement.Relationship == null) { return(null); } var possibleEnds = new List <IRelationshipEnd>(); foreach (var end in ParentElement.Relationship.Ends) { if (set.EntityType.IsOfType(end.Type)) { possibleEnds.Add(end); } } if (possibleEnds.Count == 1) { return(possibleEnds[0]); } else if (possibleEnds.Count == 0) { // no matchs AddError( ErrorCode.FailedInference, EdmSchemaErrorSeverity.Error, Strings.InferRelationshipEndFailedNoEntitySetMatch( set.Name, ParentElement.Name, ParentElement.Relationship.FQName, set.EntityType.FQName, ParentElement.ParentElement.FQName)); } else { // ambiguous AddError( ErrorCode.FailedInference, EdmSchemaErrorSeverity.Error, Strings.InferRelationshipEndAmbiguous( set.Name, ParentElement.Name, ParentElement.Relationship.FQName, set.EntityType.FQName, ParentElement.ParentElement.FQName)); } return(null); }
private static bool TypeIsSubTypeOf( SchemaEntityType itemType, Dictionary <SchemaEntityType, EntityContainerEntitySet> baseEntitySetTypes, out EntityContainerEntitySet set) { if (itemType.IsTypeHierarchyRoot) { set = (EntityContainerEntitySet)null; return(false); } for (SchemaEntityType baseType = itemType.BaseType as SchemaEntityType; baseType != null; baseType = baseType.BaseType as SchemaEntityType) { if (baseEntitySetTypes.ContainsKey(baseType)) { set = baseEntitySetTypes[baseType]; return(true); } } set = (EntityContainerEntitySet)null; return(false); }
private void ValidateOnlyBaseEntitySetTypeDefinesConcurrency() { Dictionary <SchemaEntityType, EntityContainerEntitySet> baseEntitySetTypes = new Dictionary <SchemaEntityType, EntityContainerEntitySet>(); foreach (SchemaElement member in this.Members) { EntityContainerEntitySet containerEntitySet = member as EntityContainerEntitySet; if (containerEntitySet != null && !baseEntitySetTypes.ContainsKey(containerEntitySet.EntityType)) { baseEntitySetTypes.Add(containerEntitySet.EntityType, containerEntitySet); } } foreach (SchemaType schemaType in this.Schema.SchemaTypes) { SchemaEntityType itemType = schemaType as SchemaEntityType; EntityContainerEntitySet set; if (itemType != null && EntityContainer.TypeIsSubTypeOf(itemType, baseEntitySetTypes, out set) && EntityContainer.TypeDefinesNewConcurrencyProperties(itemType)) { this.AddError(ErrorCode.ConcurrencyRedefinedOnSubTypeOfEntitySetType, EdmSchemaErrorSeverity.Error, (object)Strings.ConcurrencyRedefinedOnSubTypeOfEntitySetType((object)itemType.FQName, (object)set.EntityType.FQName, (object)set.FQName)); } } }
private static bool TypeIsSubTypeOf( SchemaEntityType itemType, Dictionary <SchemaEntityType, EntityContainerEntitySet> baseEntitySetTypes, out EntityContainerEntitySet set) { if (itemType.IsTypeHierarchyRoot) { // can't be a sub type if we are a base type set = null; return(false); } // walk up the hierarchy looking for a base that is the base type of an entityset for (var baseType = itemType.BaseType as SchemaEntityType; baseType != null; baseType = baseType.BaseType as SchemaEntityType) { if (baseEntitySetTypes.ContainsKey(baseType)) { set = baseEntitySetTypes[baseType]; return(true); } } set = null; return(false); }
internal override SchemaElement Clone(SchemaElement parentElement) { var entitySet = new EntityContainerEntitySet((EntityContainer)parentElement); entitySet._definingQueryElement = _definingQueryElement; entitySet._entityType = _entityType; entitySet._schema = _schema; entitySet._table = _table; entitySet.Name = Name; return entitySet; }
// <summary> // If the role name is missing but an entity set is given, figure out what the // relationship end should be // </summary> // <param name="set"> The given EntitySet </param> // <returns> The appropriate relationship end </returns> private IRelationshipEnd InferRelationshipEnd(EntityContainerEntitySet set) { DebugCheck.NotNull(set); if (ParentElement.Relationship == null) { return null; } var possibleEnds = new List<IRelationshipEnd>(); foreach (var end in ParentElement.Relationship.Ends) { if (set.EntityType.IsOfType(end.Type)) { possibleEnds.Add(end); } } if (possibleEnds.Count == 1) { return possibleEnds[0]; } else if (possibleEnds.Count == 0) { // no matchs AddError( ErrorCode.FailedInference, EdmSchemaErrorSeverity.Error, Strings.InferRelationshipEndFailedNoEntitySetMatch( set.Name, ParentElement.Name, ParentElement.Relationship.FQName, set.EntityType.FQName, ParentElement.ParentElement.FQName)); } else { // ambiguous AddError( ErrorCode.FailedInference, EdmSchemaErrorSeverity.Error, Strings.InferRelationshipEndAmbiguous( set.Name, ParentElement.Name, ParentElement.Relationship.FQName, set.EntityType.FQName, ParentElement.ParentElement.FQName)); } return null; }
/// <summary> /// Converts an entity set from SOM to metadata /// </summary> /// <param name="set"> The SOM element to process </param> /// <param name="container"> </param> /// <returns> The entity set object resulting from the convert </returns> private static EntitySet GetEntitySet(EntityContainerEntitySet set, EntityContainer container) { return container.GetEntitySetByName(set.Name, false); }
/// <summary> /// validate the following negative scenarios: /// ReturnType="Collection(EntityTypeA)" /// ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA" /// EntitySet="A" /// ReturnType="Collection(ComplexTypeA)" EntitySet="something" /// ReturnType="Collection(ComplexTypeA)", but the ComplexTypeA has a nested complexType property, this scenario will be handle in the runtime /// </summary> private void ValidateFunctionImportReturnType( SchemaElement owner, SchemaType returnType, EntityContainerEntitySet entitySet, bool entitySetPathDefined) { // If entity type, verify specification of entity set and that the type is appropriate for the entity set var entityType = returnType as SchemaEntityType; if (entitySet != null && entitySetPathDefined) { owner.AddError( ErrorCode.FunctionImportEntitySetAndEntitySetPathDeclared, EdmSchemaErrorSeverity.Error, Strings.FunctionImportEntitySetAndEntitySetPathDeclared(FQName)); } if (null != entityType) { // entity type if (null == entitySet) { // ReturnType="Collection(EntityTypeA)" owner.AddError( ErrorCode.FunctionImportReturnsEntitiesButDoesNotSpecifyEntitySet, EdmSchemaErrorSeverity.Error, Strings.FunctionImportReturnEntitiesButDoesNotSpecifyEntitySet(FQName)); } else if (null != entitySet.EntityType && !entityType.IsOfType(entitySet.EntityType)) { // ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA" owner.AddError( ErrorCode.FunctionImportEntityTypeDoesNotMatchEntitySet, EdmSchemaErrorSeverity.Error, Strings.FunctionImportEntityTypeDoesNotMatchEntitySet( FQName, entitySet.EntityType.FQName, entitySet.Name)); } } else { // complex type var complexType = returnType as SchemaComplexType; if (complexType != null) { if (entitySet != null || entitySetPathDefined) { // ReturnType="Collection(ComplexTypeA)" EntitySet="something" owner.AddError( ErrorCode.ComplexTypeAsReturnTypeAndDefinedEntitySet, EdmSchemaErrorSeverity.Error, owner.LineNumber, owner.LinePosition, Strings.ComplexTypeAsReturnTypeAndDefinedEntitySet(FQName, complexType.Name)); } } else { Debug.Assert( returnType == null || returnType is ScalarType || returnType is SchemaEnumType || returnType is Relationship, "null return type, scalar return type, enum return type or relationship expected here."); // scalar type or no return type if (entitySet != null || entitySetPathDefined) { // EntitySet="A" owner.AddError( ErrorCode.FunctionImportSpecifiesEntitySetButDoesNotReturnEntityType, EdmSchemaErrorSeverity.Error, Strings.FunctionImportSpecifiesEntitySetButNotEntityType(FQName)); } } } }
// <summary> // validate the following negative scenarios: // ReturnType="Collection(EntityTypeA)" // ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA" // EntitySet="A" // ReturnType="Collection(ComplexTypeA)" EntitySet="something" // ReturnType="Collection(ComplexTypeA)", but the ComplexTypeA has a nested complexType property, this scenario will be handle in the runtime // </summary> private void ValidateFunctionImportReturnType( SchemaElement owner, SchemaType returnType, EntityContainerEntitySet entitySet, bool entitySetPathDefined) { // If entity type, verify specification of entity set and that the type is appropriate for the entity set var entityType = returnType as SchemaEntityType; if (entitySet != null && entitySetPathDefined) { owner.AddError( ErrorCode.FunctionImportEntitySetAndEntitySetPathDeclared, EdmSchemaErrorSeverity.Error, Strings.FunctionImportEntitySetAndEntitySetPathDeclared(FQName)); } if (null != entityType) { // entity type if (null == entitySet) { // ReturnType="Collection(EntityTypeA)" owner.AddError( ErrorCode.FunctionImportReturnsEntitiesButDoesNotSpecifyEntitySet, EdmSchemaErrorSeverity.Error, Strings.FunctionImportReturnEntitiesButDoesNotSpecifyEntitySet(FQName)); } else if (null != entitySet.EntityType && !entityType.IsOfType(entitySet.EntityType)) { // ReturnType="Collection(EntityTypeA)" EntitySet="ESet.EType is not oftype EntityTypeA" owner.AddError( ErrorCode.FunctionImportEntityTypeDoesNotMatchEntitySet, EdmSchemaErrorSeverity.Error, Strings.FunctionImportEntityTypeDoesNotMatchEntitySet( FQName, entitySet.EntityType.FQName, entitySet.Name)); } } else { // complex type var complexType = returnType as SchemaComplexType; if (complexType != null) { if (entitySet != null || entitySetPathDefined) { // ReturnType="Collection(ComplexTypeA)" EntitySet="something" owner.AddError( ErrorCode.ComplexTypeAsReturnTypeAndDefinedEntitySet, EdmSchemaErrorSeverity.Error, owner.LineNumber, owner.LinePosition, Strings.ComplexTypeAsReturnTypeAndDefinedEntitySet(FQName, complexType.Name)); } } else { Debug.Assert( returnType == null || returnType is ScalarType || returnType is SchemaEnumType || returnType is Relationship, "null return type, scalar return type, enum return type or relationship expected here."); // scalar type or no return type if (entitySet != null || entitySetPathDefined) { // EntitySet="A" owner.AddError( ErrorCode.FunctionImportSpecifiesEntitySetButDoesNotReturnEntityType, EdmSchemaErrorSeverity.Error, Strings.FunctionImportSpecifiesEntitySetButNotEntityType(FQName)); } } } }
internal void ResolveEntitySet(SchemaElement owner, string unresolvedEntitySet, ref EntityContainerEntitySet entitySet) { Debug.Assert(IsFunctionImport, "Only FunctionImport elkements specify EntitySets"); Debug.Assert(null != _container, "function imports must know container"); // resolve entity set if (null == entitySet && null != unresolvedEntitySet) { entitySet = _container.FindEntitySet(unresolvedEntitySet); if (null == entitySet) { owner.AddError( ErrorCode.FunctionImportUnknownEntitySet, EdmSchemaErrorSeverity.Error, Strings.FunctionImportUnknownEntitySet(unresolvedEntitySet, FQName)); } } }
// <summary> // Create and add a EntityContainerEnd from the IRelationshipEnd provided // </summary> // <param name="relationshipEnd"> The relationship end of the end to add. </param> // <param name="entitySet"> The entitySet to associate with the relationship end. </param> protected override void AddEnd(IRelationshipEnd relationshipEnd, EntityContainerEntitySet entitySet) { DebugCheck.NotNull(relationshipEnd); Debug.Assert(!_relationshipEnds.ContainsKey(relationshipEnd.Name)); // we expect set to be null sometimes var end = new EntityContainerAssociationSetEnd(this); end.Role = relationshipEnd.Name; end.RelationshipEnd = relationshipEnd; end.EntitySet = entitySet; if (end.EntitySet != null) { _relationshipEnds.Add(end.Role, end); } }
protected abstract void AddEnd( IRelationshipEnd relationshipEnd, EntityContainerEntitySet entitySet);
public EntityContainerEntitySetDefiningQuery(EntityContainerEntitySet parentElement) : base((SchemaElement)parentElement, (IDbDependencyResolver)null) { }
/// <summary> /// Constructs an EntityContainerEntitySet /// </summary> /// <param name="parentElement"> Reference to the schema element. </param> public EntityContainerEntitySetDefiningQuery(EntityContainerEntitySet parentElement) : base(parentElement) { }
internal void ResolveEntitySet(SchemaElement owner, string unresolvedEntitySet, ref EntityContainerEntitySet entitySet) { Debug.Assert(IsFunctionImport, "Only FunctionImport elkements specify EntitySets"); Debug.Assert(null != _container, "function imports must know container"); // resolve entity set if (null == entitySet && null != unresolvedEntitySet) { entitySet = _container.FindEntitySet(unresolvedEntitySet); if (null == entitySet) { owner.AddError( ErrorCode.FunctionImportUnknownEntitySet, EdmSchemaErrorSeverity.Error, Strings.FunctionImportUnknownEntitySet(unresolvedEntitySet, FQName)); } } }
private void HandleEntitySetElement(XmlReader reader) { DebugCheck.NotNull(reader); var set = new EntityContainerEntitySet(this); set.Parse(reader); Members.Add(set, true, Strings.DuplicateEntityContainerMemberName); }
private void ValidateFunctionImportReturnType( SchemaElement owner, SchemaType returnType, CollectionKind returnTypeCollectionKind, EntityContainerEntitySet entitySet, bool entitySetPathDefined) { if (returnType != null && !ReturnTypeMeetsFunctionImportBasicRequirements(returnType, returnTypeCollectionKind)) { owner.AddError( ErrorCode.FunctionImportUnsupportedReturnType, EdmSchemaErrorSeverity.Error, owner, GetReturnTypeErrorMessage(Name) ); } ValidateFunctionImportReturnType(owner, returnType, entitySet, entitySetPathDefined); }
private static bool TypeIsSubTypeOf( SchemaEntityType itemType, Dictionary<SchemaEntityType, EntityContainerEntitySet> baseEntitySetTypes, out EntityContainerEntitySet set) { if (itemType.IsTypeHierarchyRoot) { // can't be a sub type if we are a base type set = null; return false; } // walk up the hierarchy looking for a base that is the base type of an entityset for (var baseType = itemType.BaseType as SchemaEntityType; baseType != null; baseType = baseType.BaseType as SchemaEntityType) { if (baseEntitySetTypes.ContainsKey(baseType)) { set = baseEntitySetTypes[baseType]; return true; } } set = null; return false; }
// <summary> // Adds a child EntitySet's tableKey (Schema/Table combination) to the validation collection // This is used to validate that no child EntitySets share a Schema.Table combination // </summary> private void CheckForDuplicateTableMapping(HashSet<string> tableKeys, EntityContainerEntitySet entitySet) { string schema; string table; if (String.IsNullOrEmpty(entitySet.DbSchema)) { // if there is no specified DbSchema, use the parent EntityContainer's name schema = Name; } else { schema = entitySet.DbSchema; } if (String.IsNullOrEmpty(entitySet.Table)) { // if there is no specified Table, use the EntitySet's name table = entitySet.Name; } else { table = entitySet.Table; } // create a key using the DbSchema and Table var tableKey = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", schema, table); if (entitySet.DefiningQuery != null) { // don't consider the schema name for defining queries, because // we can't say for sure that it is the same as the entity container // so in this example // // <EntityContainer Name="dbo"> // <EntitySet Name="ByVal"> // <DefiningQuery>Select col1 from dbi.ByVal</DefiningQuery> // </EntitySet> // <EntitySet Name="ByVal1" Table="ByVal"/> // ... // // ByVal and ByVal1 should not conflict in our check tableKey = entitySet.Name; } var alreadyExisted = !tableKeys.Add(tableKey); if (alreadyExisted) { entitySet.AddError( ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error, Strings.DuplicateEntitySetTable(entitySet.Name, schema, table)); } }
// <summary> // Constructs an EntityContainerEntitySet // </summary> // <param name="parentElement"> Reference to the schema element. </param> public EntityContainerEntitySetDefiningQuery(EntityContainerEntitySet parentElement) : base(parentElement) { }
/// <summary> /// Used during the resolve phase to resolve the type name to the object that represents that type /// </summary> internal override void ResolveTopLevelNames() { base.ResolveTopLevelNames(); if (_entitySet == null) { _entitySet = ParentElement.ParentElement.FindEntitySet(_unresolvedEntitySetName); if (_entitySet == null) { AddError( ErrorCode.InvalidEndEntitySet, EdmSchemaErrorSeverity.Error, Strings.InvalidEntitySetNameReference(_unresolvedEntitySetName, Name)); } } }
protected abstract void AddEnd(IRelationshipEnd relationshipEnd, EntityContainerEntitySet entitySet);
/// <summary> /// Converts an entity set from SOM to metadata /// </summary> /// <param name="set"> The SOM element to process </param> /// <param name="providerManifest"> The provider manifest to be used for conversion </param> /// <param name="convertedItemCache"> The item collection for currently existing metadata objects </param> /// <param name="newGlobalItems"> The new GlobalItem objects that are created as a result of this conversion </param> /// <returns> The entity set object resulting from the convert </returns> private static EntitySet ConvertToEntitySet( EntityContainerEntitySet set, DbProviderManifest providerManifest, ConversionCache convertedItemCache, Dictionary<SchemaElement, GlobalItem> newGlobalItems) { var entitySet = new EntitySet( set.Name, set.DbSchema, set.Table, set.DefiningQuery, (EntityType)LoadSchemaElement( set.EntityType, providerManifest, convertedItemCache, newGlobalItems)); // Extract the optional Documentation if (set.Documentation != null) { entitySet.Documentation = ConvertToDocumentation(set.Documentation); } AddOtherContent(set, entitySet); return entitySet; }