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