public void ConfigureFunctionParameters_should_uniquify_parameter_names() { var configuration = CreateConfiguration(); configuration.ParameterName = "Foo"; var functionParameter1 = new FunctionParameter( "P1", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var functionParameter2 = new FunctionParameter( "Foo", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); new EdmFunction( "F", "N", DataSpace.SSpace, new EdmFunctionPayload { Parameters = new[] { functionParameter1, functionParameter2 } }); configuration.ConfigureFunctionParameters(new[] { functionParameter1 }); Assert.Equal("Foo", functionParameter1.Name); Assert.Equal("Foo1", functionParameter2.Name); }
public void Cannot_create_with_null_argument() { var entityType = new EntityType("ET", "N", DataSpace.CSpace); var entitySet = new EntitySet("ES", "S", "T", "Q", entityType); var function = new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()); var parameterBindings = Enumerable.Empty<ModificationFunctionParameterBinding>(); var rowsAffectedParameter = new FunctionParameter("rows_affected", new TypeUsage(), ParameterMode.Out); var resultBindings = Enumerable.Empty<ModificationFunctionResultBinding>(); Assert.Equal( "entitySet", Assert.Throws<ArgumentNullException>( () => new ModificationFunctionMapping( null, entityType, function, parameterBindings, rowsAffectedParameter, resultBindings)).ParamName); Assert.Equal( "function", Assert.Throws<ArgumentNullException>( () => new ModificationFunctionMapping( entitySet, entityType, null, parameterBindings, rowsAffectedParameter, resultBindings)).ParamName); Assert.Equal( "parameterBindings", Assert.Throws<ArgumentNullException>( () => new ModificationFunctionMapping( entitySet, entityType, function, null, rowsAffectedParameter, resultBindings)).ParamName); }
public void VisitEdmFunction_should_visit_edm_function_parameters() { var visitorMock = new Mock<EdmModelVisitor> { CallBase = true }; var functionParameter = new FunctionParameter( "P", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var functionPayload = new EdmFunctionPayload { Parameters = new[] { functionParameter } }; var function = new EdmFunction("F", "N", DataSpace.SSpace, functionPayload); visitorMock.Object.VisitEdmFunction(function); visitorMock.Verify(v => v.VisitMetadataItem(functionParameter), Times.Once()); visitorMock.Verify(v => v.VisitFunctionParameter(functionParameter), Times.Once()); }
/// <summary> /// Initializes a new ModificationFunctionMapping instance. /// </summary> /// <param name="entitySet">The entity or association set.</param> /// <param name="entityType">The entity or association type.</param> /// <param name="function">The metadata of function to which we should bind.</param> /// <param name="parameterBindings">Bindings for function parameters.</param> /// <param name="rowsAffectedParameter">The output parameter producing number of rows affected.</param> /// <param name="resultBindings">Bindings for the results of function evaluation</param> public ModificationFunctionMapping( EntitySetBase entitySet, EntityTypeBase entityType, EdmFunction function, IEnumerable<ModificationFunctionParameterBinding> parameterBindings, FunctionParameter rowsAffectedParameter, IEnumerable<ModificationFunctionResultBinding> resultBindings) { Check.NotNull(entitySet, "entitySet"); Check.NotNull(function, "function"); Check.NotNull(parameterBindings, "parameterBindings"); _function = function; _rowsAffectedParameter = rowsAffectedParameter; _parameterBindings = new ReadOnlyCollection<ModificationFunctionParameterBinding>(parameterBindings.ToList()); if (null != resultBindings) { var bindings = resultBindings.ToList(); if (0 < bindings.Count) { _resultBindings = new ReadOnlyCollection<ModificationFunctionResultBinding>(bindings); } } _collocatedAssociationSetEnds = new ReadOnlyCollection<AssociationSetEnd>( GetReferencedAssociationSetEnds(entitySet as EntitySet, entityType as EntityType, parameterBindings) .ToList()); }
internal StorageModificationFunctionMapping( EntitySetBase entitySet, EntityTypeBase entityType, EdmFunction function, IEnumerable<StorageModificationFunctionParameterBinding> parameterBindings, FunctionParameter rowsAffectedParameter, IEnumerable<StorageModificationFunctionResultBinding> resultBindings) { DebugCheck.NotNull(entitySet); DebugCheck.NotNull(function); DebugCheck.NotNull(parameterBindings); _function = function; _rowsAffectedParameter = rowsAffectedParameter; ParameterBindings = parameterBindings.ToList().AsReadOnly(); if (null != resultBindings) { var bindings = resultBindings.ToList(); if (0 < bindings.Count) { ResultBindings = bindings.AsReadOnly(); } } CollocatedAssociationSetEnds = GetReferencedAssociationSetEnds(entitySet as EntitySet, entityType as EntityType, parameterBindings) .ToList() .AsReadOnly(); }
internal StorageModificationFunctionMapping( EntitySetBase entitySet, EntityTypeBase entityType, EdmFunction function, IEnumerable<StorageModificationFunctionParameterBinding> parameterBindings, FunctionParameter rowsAffectedParameter, IEnumerable<StorageModificationFunctionResultBinding> resultBindings) { Contract.Requires(entitySet != null); Contract.Requires(function != null); Contract.Requires(parameterBindings != null); Function = function; RowsAffectedParameter = rowsAffectedParameter; ParameterBindings = parameterBindings.ToList().AsReadOnly(); if (null != resultBindings) { var bindings = resultBindings.ToList(); if (0 < bindings.Count) { ResultBindings = bindings.AsReadOnly(); } } CollocatedAssociationSetEnds = GetReferencedAssociationSetEnds(entitySet as EntitySet, entityType as EntityType, parameterBindings) .ToList() .AsReadOnly(); }
public void SetReadOnly_is_called_on_child_mapping_items() { var parameter = new FunctionParameter(); var memberPath = new ModificationFunctionMemberPath(Enumerable.Empty<EdmMember>(), null); var parameterBinding = new ModificationFunctionParameterBinding(parameter, memberPath, true); Assert.False(memberPath.IsReadOnly); parameterBinding.SetReadOnly(); Assert.True(memberPath.IsReadOnly); }
public void Can_retrieve_properties() { var parameter = new FunctionParameter(); var memberPath = new ModificationFunctionMemberPath(Enumerable.Empty<EdmMember>(), null); var parameterBinding = new ModificationFunctionParameterBinding(parameter, memberPath, true); Assert.Same(parameter, parameterBinding.Parameter); Assert.Same(memberPath, parameterBinding.MemberPath); Assert.Equal(true, parameterBinding.IsCurrent); }
internal StorageModificationFunctionParameterBinding( FunctionParameter parameter, StorageModificationFunctionMemberPath memberPath, bool isCurrent) { DebugCheck.NotNull(parameter); DebugCheck.NotNull(memberPath); Parameter = parameter; MemberPath = memberPath; IsCurrent = isCurrent; }
/// <summary> /// Initializes a new ModificationFunctionParameterBinding instance. /// </summary> /// <param name="parameter">The parameter taking the value.</param> /// <param name="memberPath">The path to the entity or association member defining the value.</param> /// <param name="isCurrent">A flag indicating whether the current or original member value is being bound.</param> public ModificationFunctionParameterBinding( FunctionParameter parameter, ModificationFunctionMemberPath memberPath, bool isCurrent) { Check.NotNull(parameter, "parameter"); Check.NotNull(memberPath, "memberPath"); _parameter = parameter; _memberPath = memberPath; _isCurrent = isCurrent; }
internal StorageModificationFunctionParameterBinding( FunctionParameter parameter, StorageModificationFunctionMemberPath memberPath, bool isCurrent) { Contract.Requires(parameter != null); Contract.Requires(memberPath != null); Parameter = parameter; MemberPath = memberPath; IsCurrent = isCurrent; }
public void Can_get_type_name() { var function = new FunctionParameter( "P", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.InOut); Assert.Equal("String", function.TypeName); }
public void IsPrecisionConstant_returns_false_if_Precision_facet_not_present_and_value_is_null() { var typeUsage = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String), new Facet[0]); var property = new FunctionParameter("P", typeUsage, ParameterMode.In); Assert.False(property.IsPrecisionConstant); Assert.Null(property.Precision); }
public void Create_factory_method_sets_properties_and_seals_the_type() { var parameter = FunctionParameter.Create( "param", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), ParameterMode.In); Assert.Equal("param", parameter.Name); Assert.Same(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), parameter.TypeUsage.EdmType); Assert.Equal(ParameterMode.In, parameter.Mode); Assert.True(parameter.IsReadOnly); }
public void IsScaleConstant_returns_true_for_const_Scale_facet_and_value_cannot_be_changed() { var typeUsage = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String), new[] { CreateConstFacet("Scale", PrimitiveTypeKind.Byte, (byte)10) }); var property = new FunctionParameter("P", typeUsage, ParameterMode.In); Assert.True(property.IsScaleConstant); Assert.Equal(10, (byte)property.Scale); }
public void IsPrecisionConstant_returns_true_for_const_Precision_facet_and_value_cannot_be_changed() { var typeUsage = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String), new[] { CreateConstFacet("Precision", PrimitiveTypeKind.Byte, (byte)10) }); var functionParameter = new FunctionParameter("P", typeUsage, ParameterMode.In); Assert.True(functionParameter.IsPrecisionConstant); Assert.Equal(10, (byte)functionParameter.Precision); }
public void IsMaxLengthConstant_returns_true_for_const_MaxLength_facet_and_value_cannot_be_changed() { var typeUsage = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String), new[] { CreateConstFacet("MaxLength", PrimitiveTypeKind.Int32, 200) }); var property = new FunctionParameter("P", typeUsage, ParameterMode.In); Assert.True(property.IsMaxLengthConstant); Assert.Equal(200, property.MaxLength); }
internal virtual void WriteFunctionImportReturnTypeAttributes( FunctionParameter returnParameter, EntitySet entitySet, bool inline) { this._xmlWriter.WriteAttributeString(inline ? "ReturnType" : "Type", EdmXmlSchemaWriter.GetTypeName(returnParameter.TypeUsage.EdmType)); if (entitySet == null) { return; } this._xmlWriter.WriteAttributeString("EntitySet", entitySet.Name); }
/// <summary> /// Adds a parameter to this function. /// </summary> /// <param name="functionParameter">The parameter to be added.</param> public void AddParameter(FunctionParameter functionParameter) { Check.NotNull(functionParameter, "functionParameter"); Util.ThrowIfReadOnly(this); if (functionParameter.Mode == ParameterMode.ReturnValue) { throw new ArgumentException(Strings.ReturnParameterInInputParameterCollection); } _parameters.Source.Add(functionParameter); }
/// <summary> /// The factory method for constructing the <see cref="FunctionParameter" /> object. /// </summary> /// <param name="name">The name of the parameter.</param> /// <param name="edmType">The EdmType of the parameter.</param> /// <param name="parameterMode"> /// The <see cref="ParameterMode" /> of the parameter. /// </param> /// <returns> /// A new, read-only instance of the <see cref="EdmFunction" /> type. /// </returns> public static FunctionParameter Create(string name, EdmType edmType, ParameterMode parameterMode) { Check.NotEmpty(name, "name"); Check.NotNull(edmType, "edmType"); var functionParameter = new FunctionParameter(name, TypeUsage.Create(edmType, FacetValues.NullFacetValues), parameterMode); functionParameter.SetReadOnly(); return(functionParameter); }
protected internal override void VisitFunctionReturnParameter(FunctionParameter returnParameter) { if (returnParameter.TypeUsage.EdmType.BuiltInTypeKind != BuiltInTypeKind.PrimitiveType) { this._schemaWriter.WriteFunctionReturnTypeElementHeader(); base.VisitFunctionReturnParameter(returnParameter); this._schemaWriter.WriteEndElement(); } else { base.VisitFunctionReturnParameter(returnParameter); } }
public void Can_get_and_set_name() { var function = new FunctionParameter( "P", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.InOut); Assert.Equal("P", function.Name); function.Name = "Foo"; Assert.Equal("Foo", function.Name); }
public void WriteFunctionImportReturnTypeAttributes_writes_Type_attribute_for_non_inline_definition() { var fixture = new Fixture(); var returnParameter = new FunctionParameter( "RetValue", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), ParameterMode.ReturnValue); fixture.Writer.WriteFunctionReturnTypeElementHeader(); fixture.Writer.WriteFunctionImportReturnTypeAttributes(returnParameter, null, false); Assert.Equal("<ReturnType Type=\"Int32\"", fixture.ToString()); }
public void WriteFunctionImportParameterElement_writes_full_element_with_attributes() { var fixture = new Fixture(); var functionImportParameter = new FunctionParameter( "miles", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), ParameterMode.InOut); fixture.Writer.WriteFunctionImportParameterElementHeader(functionImportParameter); Assert.Equal( "<Parameter Name=\"miles\" Mode=\"InOut\" Type=\"Int32\"", fixture.ToString()); }
public void VisitFunctionReturnParameter_writes_return_and_collection_header_for_primitive_return_type() { var schemaWriterMock = new Mock <EdmXmlSchemaWriter>(); var returnParameter = new FunctionParameter( "r", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.ReturnValue); new EdmSerializationVisitor(schemaWriterMock.Object).VisitFunctionReturnParameter(returnParameter); schemaWriterMock.Verify(sw => sw.WriteFunctionReturnTypeElementHeader(), Times.Never()); schemaWriterMock.Verify(sw => sw.WriteCollectionTypeElementHeader(), Times.Never()); schemaWriterMock.Verify(sw => sw.WriteRowTypeElementHeader(), Times.Never()); schemaWriterMock.Verify(sw => sw.WriteEndElement(), Times.Never()); }
public void WriteFunctionParameterHeader_should_write_element_and_attributes() { var fixture = new Fixture(); var typeUsage = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String), new FacetValues { MaxLength = 123 }); var functionParameter = new FunctionParameter( "Foo", typeUsage, ParameterMode.In); fixture.Writer.WriteFunctionParameterHeader(functionParameter); Assert.Equal( "<Parameter Name=\"Foo\" Type=\"String\" Mode=\"In\" MaxLength=\"123\"", fixture.ToString()); fixture = new Fixture(); typeUsage = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Decimal), new FacetValues { Precision = (byte?)4, Scale = (byte?)8 }); functionParameter = new FunctionParameter( "Foo", typeUsage, ParameterMode.In); fixture.Writer.WriteFunctionParameterHeader(functionParameter); Assert.Equal( "<Parameter Name=\"Foo\" Type=\"Decimal\" Mode=\"In\" Precision=\"4\" Scale=\"8\"", fixture.ToString()); }
public void WriteFunctionImportReturnTypeAttributes_writes_EntitySet_attribute() { var fixture = new Fixture(); var returnParameter = new FunctionParameter( "RetValue", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), ParameterMode.ReturnValue); fixture.Writer.WriteFunctionReturnTypeElementHeader(); fixture.Writer.WriteFunctionImportReturnTypeAttributes(returnParameter, new EntitySet { Name = "ES" }, false); Assert.Equal("<ReturnType Type=\"Int32\" EntitySet=\"ES\"", fixture.ToString()); }
public void Cannot_create_with_null_argument() { var parameter = new FunctionParameter(); var memberPath = new ModificationFunctionMemberPath(Enumerable.Empty<EdmMember>(), null); Assert.Equal( "parameter", Assert.Throws<ArgumentNullException>( () => new ModificationFunctionParameterBinding( null, memberPath, false)).ParamName); Assert.Equal( "memberPath", Assert.Throws<ArgumentNullException>( () => new ModificationFunctionParameterBinding( parameter, null, false)).ParamName); }
public void VisitFunctionReturnParameter_writes_return_and_collection_header_for_rowtype() { var schemaWriterMock = new Mock <EdmXmlSchemaWriter>(); var returnParameter = new FunctionParameter( "r", TypeUsage.CreateDefaultTypeUsage(new RowType().GetCollectionType()), ParameterMode.ReturnValue); new EdmSerializationVisitor(schemaWriterMock.Object).VisitFunctionReturnParameter(returnParameter); schemaWriterMock.Verify(sw => sw.WriteFunctionReturnTypeElementHeader(), Times.Once()); schemaWriterMock.Verify(sw => sw.WriteCollectionTypeElementHeader(), Times.Once()); schemaWriterMock.Verify(sw => sw.WriteRowTypeElementHeader(), Times.Once()); schemaWriterMock.Verify(sw => sw.WriteEndElement(), Times.Exactly(3)); }
public void Can_get_facets_via_property_wrappers() { var typeUsage = TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String), new[] { CreateConstFacet("Precision", PrimitiveTypeKind.Byte, (byte)10), CreateConstFacet("Scale", PrimitiveTypeKind.Byte, (byte)10), CreateConstFacet("MaxLength", PrimitiveTypeKind.Int32, 200) }); var functionParameter = new FunctionParameter("P", typeUsage, ParameterMode.In); Assert.Equal(200, functionParameter.MaxLength.Value); Assert.Equal(10, functionParameter.Precision.Value); Assert.Equal(10, functionParameter.Scale.Value); }
public void EdmFunction_DuplicateParameterName() { var validationContext = new EdmModelValidationContext(new EdmModel(DataSpace.SSpace), true); DataModelErrorEventArgs errorEventArgs = null; validationContext.OnError += (_, e) => errorEventArgs = e; var parameter1 = new FunctionParameter( "P", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var parameter2 = new FunctionParameter( "P2", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var function = new EdmFunction( "F", "N", DataSpace.SSpace, new EdmFunctionPayload { Parameters = new[] { parameter1, parameter2 } }); parameter2.Name = "P"; EdmModelSemanticValidationRules .EdmFunction_DuplicateParameterName .Evaluate(validationContext, function); Assert.NotNull(errorEventArgs); Assert.Same(parameter2, errorEventArgs.Item); Assert.Equal( Strings.ParameterNameAlreadyDefinedDuplicate("P"), errorEventArgs.ErrorMessage); }
public void Can_retrieve_properties() { var entityType = new EntityType("ET", "N", DataSpace.CSpace); var entitySet = new EntitySet("ES", "S", "T", "Q", entityType); var entityContainer = new EntityContainer("EC", DataSpace.SSpace); entityContainer.AddEntitySetBase(entitySet); var function = new EdmFunction("F", "N", DataSpace.SSpace, new EdmFunctionPayload()); var parameterBindings = new[] { new ModificationFunctionParameterBinding( new FunctionParameter(), new ModificationFunctionMemberPath(Enumerable.Empty<EdmMember>(), null), true) }; var rowsAffectedParameter = new FunctionParameter("rows_affected", new TypeUsage(), ParameterMode.Out); var resultBindings = new[] { new ModificationFunctionResultBinding( "C", EdmProperty.CreatePrimitive( "P", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String))) }; var mapping = new ModificationFunctionMapping( entitySet, entityType, function, parameterBindings, rowsAffectedParameter, resultBindings); Assert.Same(rowsAffectedParameter, mapping.RowsAffectedParameter); Assert.Same(function, mapping.Function); Assert.Equal(parameterBindings, mapping.ParameterBindings); Assert.Equal(resultBindings, mapping.ResultBindings); }
public virtual void WriteFunctionParameterHeader(FunctionParameter functionParameter) { this._xmlWriter.WriteStartElement("Parameter"); this._xmlWriter.WriteAttributeString("Name", functionParameter.Name); this._xmlWriter.WriteAttributeString("Type", functionParameter.TypeName); this._xmlWriter.WriteAttributeString("Mode", functionParameter.Mode.ToString()); if (functionParameter.IsMaxLength) { this._xmlWriter.WriteAttributeString("MaxLength", "Max"); } else if (!functionParameter.IsMaxLengthConstant && functionParameter.MaxLength.HasValue) { this._xmlWriter.WriteAttributeString("MaxLength", functionParameter.MaxLength.Value.ToString((IFormatProvider)CultureInfo.InvariantCulture)); } if (!functionParameter.IsPrecisionConstant && functionParameter.Precision.HasValue) { this._xmlWriter.WriteAttributeString("Precision", functionParameter.Precision.Value.ToString((IFormatProvider)CultureInfo.InvariantCulture)); } if (functionParameter.IsScaleConstant || !functionParameter.Scale.HasValue) { return; } this._xmlWriter.WriteAttributeString("Scale", functionParameter.Scale.Value.ToString((IFormatProvider)CultureInfo.InvariantCulture)); }
public virtual void WriteFunctionParameterHeader(FunctionParameter functionParameter) { DebugCheck.NotNull(functionParameter); _xmlWriter.WriteStartElement(XmlConstants.Parameter); _xmlWriter.WriteAttributeString(XmlConstants.Name, functionParameter.Name); _xmlWriter.WriteAttributeString(XmlConstants.TypeAttribute, functionParameter.TypeName); _xmlWriter.WriteAttributeString(XmlConstants.Mode, functionParameter.Mode.ToString()); if (functionParameter.IsMaxLength) { _xmlWriter.WriteAttributeString(XmlConstants.MaxLengthElement, XmlConstants.Max); } else if (!functionParameter.IsMaxLengthConstant && functionParameter.MaxLength.HasValue) { _xmlWriter.WriteAttributeString( XmlConstants.MaxLengthElement, functionParameter.MaxLength.Value.ToString(CultureInfo.InvariantCulture)); } if (!functionParameter.IsPrecisionConstant && functionParameter.Precision.HasValue) { _xmlWriter.WriteAttributeString( XmlConstants.PrecisionElement, functionParameter.Precision.Value.ToString(CultureInfo.InvariantCulture)); } if (!functionParameter.IsScaleConstant && functionParameter.Scale.HasValue) { _xmlWriter.WriteAttributeString( XmlConstants.ScaleElement, functionParameter.Scale.Value.ToString(CultureInfo.InvariantCulture)); } }
public void Can_configure_ia_fk_parameters() { var modificationFunctionConfiguration = new ModificationFunctionConfiguration(); var mockPropertyInfo1 = new MockPropertyInfo(); var mockPropertyInfo2 = new MockPropertyInfo(); modificationFunctionConfiguration .Parameter(new PropertyPath(new[] { mockPropertyInfo1.Object, mockPropertyInfo2.Object }), "Foo"); var entitySet = new EntitySet(); entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace)); var property1 = new EdmProperty("P1"); property1.SetClrPropertyInfo(mockPropertyInfo1); var function = new EdmFunction("F", "N", DataSpace.SSpace); var functionParameter1 = new FunctionParameter(); var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); var associationEndMember1 = new AssociationEndMember("AE1", new EntityType("E", "N", DataSpace.CSpace)) { RelationshipMultiplicity = RelationshipMultiplicity.Many }; var associationEndMember2 = new AssociationEndMember("AE2", new EntityType("E", "N", DataSpace.CSpace)) { RelationshipMultiplicity = RelationshipMultiplicity.One }; associationEndMember2.SetClrPropertyInfo(mockPropertyInfo1); associationType.SourceEnd = associationEndMember1; associationType.TargetEnd = associationEndMember2; var associationSet = new AssociationSet("AS", associationType); associationSet.AddAssociationSetEnd( new AssociationSetEnd(entitySet, associationSet, associationEndMember2)); modificationFunctionConfiguration.Configure( new StorageModificationFunctionMapping( entitySet, new EntityType("E", "N", DataSpace.CSpace), function, new[] { new StorageModificationFunctionParameterBinding( functionParameter1, new StorageModificationFunctionMemberPath( new EdmMember[] { property1, associationEndMember2 }, associationSet), false) }, null, null), ProviderRegistry.Sql2008_ProviderManifest); Assert.Equal("Foo", functionParameter1.Name); }
protected internal override void VisitFunctionImportParameter(FunctionParameter parameter) { _schemaWriter.WriteFunctionImportParameterElementHeader(parameter); base.VisitFunctionImportParameter(parameter); _schemaWriter.WriteEndElement(); }
protected internal override void VisitFunctionParameter(FunctionParameter functionParameter) { this._schemaWriter.WriteFunctionParameterHeader(functionParameter); base.VisitFunctionParameter(functionParameter); this._schemaWriter.WriteEndElement(); }
// <summary> // Convert the S type function parameters and returnType to C types. // </summary> internal static EdmFunction ConvertFunctionSignatureToCType(EdmFunction sTypeFunction) { Debug.Assert(sTypeFunction.DataSpace == DataSpace.SSpace, "sTypeFunction.DataSpace == Edm.DataSpace.SSpace"); if (sTypeFunction.IsFromProviderManifest) { return(sTypeFunction); } FunctionParameter returnParameter = null; if (sTypeFunction.ReturnParameter != null) { var edmTypeUsageReturnParameter = MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(sTypeFunction.ReturnParameter.TypeUsage); returnParameter = new FunctionParameter( sTypeFunction.ReturnParameter.Name, edmTypeUsageReturnParameter, sTypeFunction.ReturnParameter.GetParameterMode()); } var parameters = new List <FunctionParameter>(); if (sTypeFunction.Parameters.Count > 0) { foreach (var parameter in sTypeFunction.Parameters) { var edmTypeUsage = MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(parameter.TypeUsage); var edmTypeParameter = new FunctionParameter(parameter.Name, edmTypeUsage, parameter.GetParameterMode()); parameters.Add(edmTypeParameter); } } var returnParameters = returnParameter == null ? new FunctionParameter[0] : new[] { returnParameter }; var edmFunction = new EdmFunction( sTypeFunction.Name, sTypeFunction.NamespaceName, DataSpace.CSpace, new EdmFunctionPayload { Schema = sTypeFunction.Schema, StoreFunctionName = sTypeFunction.StoreFunctionNameAttribute, CommandText = sTypeFunction.CommandTextAttribute, IsAggregate = sTypeFunction.AggregateAttribute, IsBuiltIn = sTypeFunction.BuiltInAttribute, IsNiladic = sTypeFunction.NiladicFunctionAttribute, IsComposable = sTypeFunction.IsComposableAttribute, IsFromProviderManifest = sTypeFunction.IsFromProviderManifest, IsCachedStoreFunction = true, IsFunctionImport = sTypeFunction.IsFunctionImport, ReturnParameters = returnParameters, Parameters = parameters.ToArray(), ParameterTypeSemantics = sTypeFunction.ParameterTypeSemanticsAttribute, }); edmFunction.SetReadOnly(); return(edmFunction); }
/// <summary> /// Convert the S type function parameters and returnType to C types. /// </summary> private EdmFunction ConvertFunctionSignatureToCType(EdmFunction sTypeFunction) { Debug.Assert(sTypeFunction.DataSpace == DataSpace.SSpace, "sTypeFunction.DataSpace == Edm.DataSpace.SSpace"); if (sTypeFunction.IsFromProviderManifest) { return sTypeFunction; } FunctionParameter returnParameter = null; if (sTypeFunction.ReturnParameter != null) { var edmTypeUsageReturnParameter = MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(sTypeFunction.ReturnParameter.TypeUsage); returnParameter = new FunctionParameter( sTypeFunction.ReturnParameter.Name, edmTypeUsageReturnParameter, sTypeFunction.ReturnParameter.GetParameterMode()); } var parameters = new List<FunctionParameter>(); if (sTypeFunction.Parameters.Count > 0) { foreach (var parameter in sTypeFunction.Parameters) { var edmTypeUsage = MetadataHelper.ConvertStoreTypeUsageToEdmTypeUsage(parameter.TypeUsage); var edmTypeParameter = new FunctionParameter(parameter.Name, edmTypeUsage, parameter.GetParameterMode()); parameters.Add(edmTypeParameter); } } var returnParameters = returnParameter == null ? new FunctionParameter[0] : new[] { returnParameter }; var edmFunction = new EdmFunction( sTypeFunction.Name, sTypeFunction.NamespaceName, DataSpace.CSpace, new EdmFunctionPayload { Schema = sTypeFunction.Schema, StoreFunctionName = sTypeFunction.StoreFunctionNameAttribute, CommandText = sTypeFunction.CommandTextAttribute, IsAggregate = sTypeFunction.AggregateAttribute, IsBuiltIn = sTypeFunction.BuiltInAttribute, IsNiladic = sTypeFunction.NiladicFunctionAttribute, IsComposable = sTypeFunction.IsComposableAttribute, IsFromProviderManifest = sTypeFunction.IsFromProviderManifest, IsCachedStoreFunction = true, IsFunctionImport = sTypeFunction.IsFunctionImport, ReturnParameters = returnParameters, Parameters = parameters.ToArray(), ParameterTypeSemantics = sTypeFunction.ParameterTypeSemanticsAttribute, }); edmFunction.SetReadOnly(); return edmFunction; }
private static EdmFunction ConvertToFunction( Som.Function somFunction, DbProviderManifest providerManifest, ConversionCache convertedItemCache, EntityContainer functionImportEntityContainer, Dictionary<Som.SchemaElement, GlobalItem> newGlobalItems) { // If we already have it, don't bother converting GlobalItem globalItem = null; // if we are converted the function import, we need not check the global items collection, // since the function imports are local to the entity container if (!somFunction.IsFunctionImport && newGlobalItems.TryGetValue(somFunction, out globalItem)) { return (EdmFunction)globalItem; } var areConvertingForProviderManifest = somFunction.Schema.DataModel == Som.SchemaDataModelOption.ProviderManifestModel; var returnParameters = new List<FunctionParameter>(); if (somFunction.ReturnTypeList != null) { var i = 0; foreach (var somReturnType in somFunction.ReturnTypeList) { var returnType = GetFunctionTypeUsage( somFunction is Som.ModelFunction, somFunction, somReturnType, providerManifest, areConvertingForProviderManifest, somReturnType.Type, somReturnType.CollectionKind, somReturnType.IsRefType /*isRefType*/, convertedItemCache, newGlobalItems); if (null != returnType) { // Create the return parameter object, need to set the declaring type explicitly on the return parameter // because we aren't adding it to the members collection var modifier = i == 0 ? string.Empty : i.ToString(CultureInfo.InvariantCulture); i++; var returnParameter = new FunctionParameter( EdmConstants.ReturnType + modifier, returnType, ParameterMode.ReturnValue); AddOtherContent(somReturnType, returnParameter); returnParameters.Add(returnParameter); } else { return null; } } } // this case must be second to avoid calling somFunction.Type when returnTypeList has more than one element. else if (somFunction.Type != null) { var returnType = GetFunctionTypeUsage( somFunction is Som.ModelFunction, somFunction, null, providerManifest, areConvertingForProviderManifest, somFunction.Type, somFunction.CollectionKind, somFunction.IsReturnAttributeReftype /*isRefType*/, convertedItemCache, newGlobalItems); if (null != returnType) { // Create the return parameter object, need to set the declaring type explicitly on the return parameter // because we aren't adding it to the members collection returnParameters.Add(new FunctionParameter(EdmConstants.ReturnType, returnType, ParameterMode.ReturnValue)); } else { //Return type was specified but we could not find a type usage return null; } } string functionNamespace; EntitySet[] entitySets = null; if (somFunction.IsFunctionImport) { var somFunctionImport = (Som.FunctionImportElement)somFunction; functionNamespace = somFunctionImport.Container.Name; if (null != somFunctionImport.EntitySet) { EntityContainer entityContainer; Debug.Assert( somFunctionImport.ReturnTypeList == null || somFunctionImport.ReturnTypeList.Count == 1, "EntitySet cannot be specified on a FunctionImport if there are multiple ReturnType children"); Debug.Assert( functionImportEntityContainer != null, "functionImportEntityContainer must be specified during function import conversion"); entityContainer = functionImportEntityContainer; entitySets = new[] { GetEntitySet(somFunctionImport.EntitySet, entityContainer) }; } else if (null != somFunctionImport.ReturnTypeList) { Debug.Assert( functionImportEntityContainer != null, "functionImportEntityContainer must be specified during function import conversion"); var entityContainer = functionImportEntityContainer; entitySets = somFunctionImport.ReturnTypeList .Select( returnType => null != returnType.EntitySet ? GetEntitySet(returnType.EntitySet, functionImportEntityContainer) : null) .ToArray(); } } else { functionNamespace = somFunction.Namespace; } var parameters = new List<FunctionParameter>(); foreach (var somParameter in somFunction.Parameters) { var parameterType = GetFunctionTypeUsage( somFunction is Som.ModelFunction, somFunction, somParameter, providerManifest, areConvertingForProviderManifest, somParameter.Type, somParameter.CollectionKind, somParameter.IsRefType, convertedItemCache, newGlobalItems); if (parameterType == null) { return null; } var parameter = new FunctionParameter( somParameter.Name, parameterType, GetParameterMode(somParameter.ParameterDirection)); AddOtherContent(somParameter, parameter); if (somParameter.Documentation != null) { parameter.Documentation = ConvertToDocumentation(somParameter.Documentation); } parameters.Add(parameter); } var function = new EdmFunction( somFunction.Name, functionNamespace, GetDataSpace(providerManifest), new EdmFunctionPayload { Schema = somFunction.DbSchema, StoreFunctionName = somFunction.StoreFunctionName, CommandText = somFunction.CommandText, EntitySets = entitySets, IsAggregate = somFunction.IsAggregate, IsBuiltIn = somFunction.IsBuiltIn, IsNiladic = somFunction.IsNiladicFunction, IsComposable = somFunction.IsComposable, IsFromProviderManifest = areConvertingForProviderManifest, IsFunctionImport = somFunction.IsFunctionImport, ReturnParameters = returnParameters.ToArray(), Parameters = parameters.ToArray(), ParameterTypeSemantics = somFunction.ParameterTypeSemantics, }); // Add this function to new global items, only if it is not a function import if (!somFunction.IsFunctionImport) { newGlobalItems.Add(somFunction, function); } //Check if we already converted functions since we are loading it from //ssdl we could see functions many times. GlobalItem returnFunction = null; Debug.Assert( !convertedItemCache.ItemCollection.TryGetValue(function.Identity, false, out returnFunction), "Function duplicates must be checked by som"); // Extract the optional Documentation if (somFunction.Documentation != null) { function.Documentation = ConvertToDocumentation(somFunction.Documentation); } AddOtherContent(somFunction, function); return function; }
private static EdmFunction ConvertToFunction( System.Data.Entity.Core.SchemaObjectModel.Function somFunction, DbProviderManifest providerManifest, Converter.ConversionCache convertedItemCache, EntityContainer functionImportEntityContainer, Dictionary <SchemaElement, GlobalItem> newGlobalItems) { GlobalItem globalItem = (GlobalItem)null; if (!somFunction.IsFunctionImport && newGlobalItems.TryGetValue((SchemaElement)somFunction, out globalItem)) { return((EdmFunction)globalItem); } bool areConvertingForProviderManifest = somFunction.Schema.DataModel == SchemaDataModelOption.ProviderManifestModel; List <FunctionParameter> functionParameterList1 = new List <FunctionParameter>(); if (somFunction.ReturnTypeList != null) { int num = 0; foreach (ReturnType returnType in (IEnumerable <ReturnType>)somFunction.ReturnTypeList) { TypeUsage functionTypeUsage = Converter.GetFunctionTypeUsage(somFunction is ModelFunction, somFunction, (FacetEnabledSchemaElement)returnType, providerManifest, areConvertingForProviderManifest, returnType.Type, returnType.CollectionKind, returnType.IsRefType, convertedItemCache, newGlobalItems); if (functionTypeUsage == null) { return((EdmFunction)null); } string str = num == 0 ? string.Empty : num.ToString((IFormatProvider)CultureInfo.InvariantCulture); ++num; FunctionParameter functionParameter = new FunctionParameter("ReturnType" + str, functionTypeUsage, ParameterMode.ReturnValue); Converter.AddOtherContent((SchemaElement)returnType, (MetadataItem)functionParameter); functionParameterList1.Add(functionParameter); } } else if (somFunction.Type != null) { TypeUsage functionTypeUsage = Converter.GetFunctionTypeUsage(somFunction is ModelFunction, somFunction, (FacetEnabledSchemaElement)null, providerManifest, areConvertingForProviderManifest, somFunction.Type, somFunction.CollectionKind, somFunction.IsReturnAttributeReftype, convertedItemCache, newGlobalItems); if (functionTypeUsage == null) { return((EdmFunction)null); } functionParameterList1.Add(new FunctionParameter("ReturnType", functionTypeUsage, ParameterMode.ReturnValue)); } EntitySet[] entitySetArray = (EntitySet[])null; string name; if (somFunction.IsFunctionImport) { FunctionImportElement functionImportElement = (FunctionImportElement)somFunction; name = functionImportElement.Container.Name; if (functionImportElement.EntitySet != null) { EntityContainer container = functionImportEntityContainer; entitySetArray = new EntitySet[1] { Converter.GetEntitySet(functionImportElement.EntitySet, container) }; } else if (functionImportElement.ReturnTypeList != null) { EntityContainer entityContainer = functionImportEntityContainer; entitySetArray = functionImportElement.ReturnTypeList.Select <ReturnType, EntitySet>((Func <ReturnType, EntitySet>)(returnType => { if (returnType.EntitySet == null) { return((EntitySet)null); } return(Converter.GetEntitySet(returnType.EntitySet, functionImportEntityContainer)); })).ToArray <EntitySet>(); } } else { name = somFunction.Namespace; } List <FunctionParameter> functionParameterList2 = new List <FunctionParameter>(); foreach (Parameter parameter in somFunction.Parameters) { TypeUsage functionTypeUsage = Converter.GetFunctionTypeUsage(somFunction is ModelFunction, somFunction, (FacetEnabledSchemaElement)parameter, providerManifest, areConvertingForProviderManifest, parameter.Type, parameter.CollectionKind, parameter.IsRefType, convertedItemCache, newGlobalItems); if (functionTypeUsage == null) { return((EdmFunction)null); } FunctionParameter functionParameter = new FunctionParameter(parameter.Name, functionTypeUsage, Converter.GetParameterMode(parameter.ParameterDirection)); Converter.AddOtherContent((SchemaElement)parameter, (MetadataItem)functionParameter); if (parameter.Documentation != null) { functionParameter.Documentation = Converter.ConvertToDocumentation(parameter.Documentation); } functionParameterList2.Add(functionParameter); } EdmFunction edmFunction = new EdmFunction(somFunction.Name, name, Converter.GetDataSpace(providerManifest), new EdmFunctionPayload() { Schema = somFunction.DbSchema, StoreFunctionName = somFunction.StoreFunctionName, CommandText = somFunction.CommandText, EntitySets = (IList <EntitySet>)entitySetArray, IsAggregate = new bool?(somFunction.IsAggregate), IsBuiltIn = new bool?(somFunction.IsBuiltIn), IsNiladic = new bool?(somFunction.IsNiladicFunction), IsComposable = new bool?(somFunction.IsComposable), IsFromProviderManifest = new bool?(areConvertingForProviderManifest), IsFunctionImport = new bool?(somFunction.IsFunctionImport), ReturnParameters = (IList <FunctionParameter>)functionParameterList1.ToArray(), Parameters = (IList <FunctionParameter>)functionParameterList2.ToArray(), ParameterTypeSemantics = new ParameterTypeSemantics?(somFunction.ParameterTypeSemantics) }); if (!somFunction.IsFunctionImport) { newGlobalItems.Add((SchemaElement)somFunction, (GlobalItem)edmFunction); } if (somFunction.Documentation != null) { edmFunction.Documentation = Converter.ConvertToDocumentation(somFunction.Documentation); } Converter.AddOtherContent((SchemaElement)somFunction, (MetadataItem)edmFunction); return(edmFunction); }
protected internal override void VisitFunctionImportReturnParameter(FunctionParameter parameter) { // function imports with multiple return types are currently not supported // for function with single return value the return type is being written inline }
public void WriteFunctionImportHeader_writes_element_and_attributes() { var fixture = new Fixture(); var complexType = new ComplexType("CT", "N", DataSpace.CSpace); var returnParameter = new FunctionParameter( "ReturnValue", TypeUsage.CreateDefaultTypeUsage(complexType.GetCollectionType()), ParameterMode.ReturnValue); var functionPayload = new EdmFunctionPayload { IsComposable = true, ReturnParameters = new[] { returnParameter }, }; var functionImport = new EdmFunction("foo", "nction", DataSpace.CSpace, functionPayload); fixture.Writer.WriteFunctionImportElementHeader(functionImport); Assert.Equal( "<FunctionImport Name=\"foo\" IsComposable=\"true\"", fixture.ToString()); }
protected virtual void Visit(FunctionParameter functionParameter) { Visit(functionParameter.DeclaringFunction); Visit(functionParameter.TypeUsage); }
public void WriteFunctionImportHeader_writes_IsComposable_attribute_if_it_is_false() { var fixture = new Fixture(); var returnParameter = new FunctionParameter( "ReturnValue", TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32)), ParameterMode.ReturnValue); var functionPayload = new EdmFunctionPayload { IsComposable = false, ReturnParameters = new[] { returnParameter }, }; var functionImport = new EdmFunction("foo", "nction", DataSpace.CSpace, functionPayload); fixture.Writer.WriteFunctionImportElementHeader(functionImport); Assert.Equal( "<FunctionImport Name=\"foo\"", fixture.ToString()); }
public void Can_configure_function_name_and_parameters() { var modificationFunctionConfiguration = new ModificationFunctionConfiguration(); modificationFunctionConfiguration.HasName("Foo", "Bar"); var mockPropertyInfo1 = new MockPropertyInfo(); var mockPropertyInfo2 = new MockPropertyInfo(); modificationFunctionConfiguration .Parameter(new PropertyPath(mockPropertyInfo1), "Foo"); modificationFunctionConfiguration .Parameter(new PropertyPath(new[] { mockPropertyInfo1.Object, mockPropertyInfo2.Object }), "Bar"); var entitySet = new EntitySet(); entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace)); var property1 = new EdmProperty("P1"); property1.SetClrPropertyInfo(mockPropertyInfo1); var property2 = new EdmProperty("P1"); property2.SetClrPropertyInfo(mockPropertyInfo2); var functionParameter1 = new FunctionParameter( "P1", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var functionParameter2 = new FunctionParameter( "P2", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var functionParameter3 = new FunctionParameter( "Foo", TypeUsage.Create(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In); var function = new EdmFunction( "F", "N", DataSpace.SSpace, new EdmFunctionPayload { Parameters = new[] { functionParameter1, functionParameter2, functionParameter3 } }); var associationType = new AssociationType("A", XmlConstants.ModelNamespace_3, false, DataSpace.CSpace); var associationEndMember1 = new AssociationEndMember("AE1", new EntityType("E", "N", DataSpace.CSpace)) { RelationshipMultiplicity = RelationshipMultiplicity.Many }; var associationEndMember2 = new AssociationEndMember("AE2", new EntityType("E", "N", DataSpace.CSpace)) { RelationshipMultiplicity = RelationshipMultiplicity.Many }; associationType.SourceEnd = associationEndMember1; associationType.TargetEnd = associationEndMember2; var associationSet = new AssociationSet("AS", associationType); associationSet.AddAssociationSetEnd( new AssociationSetEnd(entitySet, associationSet, associationEndMember2)); modificationFunctionConfiguration.Configure( new StorageModificationFunctionMapping( entitySet, new EntityType("E", "N", DataSpace.CSpace), function, new[] { new StorageModificationFunctionParameterBinding( functionParameter1, new StorageModificationFunctionMemberPath( new EdmMember[] { property1, associationEndMember2 }, associationSet), false), new StorageModificationFunctionParameterBinding( functionParameter2, new StorageModificationFunctionMemberPath( new[] { property1, property2 }, null), false) }, null, null), ProviderRegistry.Sql2008_ProviderManifest); Assert.Equal("Foo", function.StoreFunctionNameAttribute); Assert.Equal("Bar", function.Schema); Assert.Equal("Foo", functionParameter1.Name); Assert.Equal("Bar", functionParameter2.Name); Assert.Equal("Foo1", functionParameter3.Name); }
public void Can_configure_rows_affected_parameter_name() { var modificationFunctionConfiguration = new ModificationFunctionConfiguration(); var mockPropertyInfo = new MockPropertyInfo(); modificationFunctionConfiguration.RowsAffectedParameter("Foo"); var entitySet = new EntitySet(); entitySet.ChangeEntityContainerWithoutCollectionFixup(new EntityContainer("C", DataSpace.CSpace)); var property = new EdmProperty("P1"); property.SetClrPropertyInfo(mockPropertyInfo); var rowsAffectedParameter = new FunctionParameter(); modificationFunctionConfiguration.Configure( new StorageModificationFunctionMapping( entitySet, new EntityType("E", "N", DataSpace.CSpace), new EdmFunction("F", "N", DataSpace.SSpace), new[] { new StorageModificationFunctionParameterBinding( new FunctionParameter( "P", TypeUsage.Create( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)), ParameterMode.In), new StorageModificationFunctionMemberPath(new[] { property }, null), false) }, rowsAffectedParameter, null), ProviderRegistry.Sql2008_ProviderManifest); Assert.Equal("Foo", rowsAffectedParameter.Name); }
private void ConfigureRowsAffectedParameter( StorageModificationFunctionMapping modificationFunctionMapping, DbProviderManifest providerManifest) { DebugCheck.NotNull(modificationFunctionMapping); DebugCheck.NotNull(providerManifest); if (!string.IsNullOrWhiteSpace(_rowsAffectedParameter)) { if (modificationFunctionMapping.RowsAffectedParameter == null) { var rowsAffectedParameter = new FunctionParameter( "_RowsAffected_", providerManifest.GetStoreType( TypeUsage.CreateDefaultTypeUsage( PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32))), ParameterMode.Out); modificationFunctionMapping.Function.AddParameter(rowsAffectedParameter); modificationFunctionMapping.RowsAffectedParameter = rowsAffectedParameter; } modificationFunctionMapping.RowsAffectedParameter.Name = _rowsAffectedParameter; _configuredParameters.Add(modificationFunctionMapping.RowsAffectedParameter); } }