public void CollectStoreModelErrors_returns_errors_from_function_return_rowtypes()
{
var edmSchemaError = new EdmSchemaError("msg", 42, EdmSchemaErrorSeverity.Error);
var errorMetadataProperty =
MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()),
new List <EdmSchemaError> {
edmSchemaError
});
var rowType = RowType.Create(new EdmProperty[0], new[] { errorMetadataProperty });
var function =
EdmFunction.Create(
"foo",
"bar",
DataSpace.SSpace,
new EdmFunctionPayload
{
ReturnParameters =
new[]
{
FunctionParameter.Create(
"ReturnType",
rowType,
ParameterMode.ReturnValue)
}
},
null);
var model = new EdmModel(DataSpace.SSpace);
model.AddItem(function);
var schemaErrors = ModelGenerator.CollectStoreModelErrors(model);
Assert.NotNull(schemaErrors);
Assert.Equal(1, schemaErrors.Count);
Assert.Same(edmSchemaError, schemaErrors.Single());
}
public IErrorReporter InheritanceSpecializedOverloadCall()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
GlobalVariables = true, RelaxedMode = true
}.SetMutability(mutability));
var root_ns = env.Root;
var func_def1 = root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), usageMode: ExpressionReadMode.CannotBeRead)));
var func_def2 = root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.IObjectNameReference(), usageMode: ExpressionReadMode.CannotBeRead)));
root_ns.AddNode(VariableDeclaration.CreateStatement("i", NameFactory.Int64NameReference(), Undef.Create(),
modifier: EntityModifier.Public));
var call1 = FunctionCall.Create(NameReference.Create("foo"), FunctionArgument.Create(NameReference.Create("i")));
root_ns.AddNode(VariableDeclaration.CreateStatement("x", NameFactory.RealNameReference(),
call1, modifier: EntityModifier.Public));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count());
Assert.AreEqual(func_def1, call1.Resolution.TargetFunctionInstance.Target);
}
return(resolver);
}
public IErrorReporter TranslationTableOfInferredCommonTypes()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
TemplateParameter template_param = TemplateParametersBuffer.Create("T").Values.Single();
root_ns.AddBuilder(FunctionBuilder.Create("getMe", new[] { template_param },
ExpressionReadMode.OptionalUse,
NameFactory.UnitNameReference(), Block.CreateStatement())
.Parameters(FunctionParameter.Create("a", NameFactory.ReferenceNameReference("T"), ExpressionReadMode.CannotBeRead),
FunctionParameter.Create("b", NameFactory.ReferenceNameReference("T"), ExpressionReadMode.CannotBeRead)));
FunctionCall call = FunctionCall.Create(NameReference.Create("getMe"), NameReference.Create("x"), NameReference.Create("y"));
root_ns.AddBuilder(FunctionBuilder.Create("common",
NameFactory.UnitNameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("x", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()),
Int64Literal.Create("3")),
VariableDeclaration.CreateStatement("y", NameFactory.ReferenceNameReference(NameFactory.BoolNameReference()),
BoolLiteral.CreateTrue()),
call
)));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
// the actual point of this test are those two lines checking if we get correct translation table for entire
// instance of the called function
Assert.IsTrue(call.Resolution.TargetFunctionInstance.Translation.Translate(template_param,
out IEntityInstance common_instance));
Assert.AreEqual(resolver.Context.Env.IEquatableType.InstanceOf, common_instance);
}
return(resolver);
}
public IErrorReporter ProperGenericMethodOverride()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("IX", TemplateParametersBuffer.Create()
.Add("T")
.Values))
.With(FunctionBuilder.CreateDeclaration(
"bar",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference())
.Parameters(FunctionParameter.Create("x", NameReference.Create("T"), Variadic.None, null, isNameRequired: false)))
.SetModifier(EntityModifier.Interface));
TypeDefinition type_impl = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("X", TemplateParametersBuffer.Create()
.Add("V").Values))
.With(FunctionBuilder.Create(
"bar",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("2"))
}))
.Parameters(FunctionParameter.Create("x", NameReference.Create("V"), usageMode: ExpressionReadMode.CannotBeRead))
.SetModifier(EntityModifier.Override))
.Parents(NameReference.Create("IX", NameReference.Create("V"))));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
}
return(resolver);
}
public IErrorReporter ErrorInvalidConverters()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
FunctionDefinition conv1 = FunctionBuilder.Create(NameFactory.ConvertFunctionName,
NameFactory.Int64NameReference(),
Block.CreateStatement(Return.Create(Int64Literal.Create("3"))));
FunctionDefinition conv2 = FunctionBuilder.Create(NameFactory.ConvertFunctionName,
ExpressionReadMode.OptionalUse,
NameFactory.BoolNameReference(),
Block.CreateStatement(Return.Create(Undef.Create())))
.SetModifier(EntityModifier.Pinned);
FunctionDefinition conv3 = FunctionBuilder.Create(NameFactory.ConvertFunctionName,
NameFactory.StringPointerNameReference(),
Block.CreateStatement(Return.Create(Undef.Create())))
.SetModifier(EntityModifier.Pinned)
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead));
root_ns.AddBuilder(TypeBuilder.Create("Start")
.SetModifier(EntityModifier.Base)
.With(conv1)
.With(conv2)
.With(conv3));
resolver = NameResolver.Create(env);
Assert.AreEqual(3, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ConverterNotPinned, conv1));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ConverterDeclaredWithIgnoredOutput, conv2));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ConverterWithParameters, conv3));
}
return(resolver);
}
private static DbCompiledModel CreateModel(NpgsqlConnection connection)
{
var dbModelBuilder = new DbModelBuilder(DbModelBuilderVersion.Latest);
// Import Sets
dbModelBuilder.Entity <Blog>();
dbModelBuilder.Entity <Post>();
dbModelBuilder.Entity <NoColumnsEntity>();
// Import function
var dbModel = dbModelBuilder.Build(connection);
var edmType = PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32);
var payload = new EdmFunctionPayload
{
ParameterTypeSemantics = ParameterTypeSemantics.AllowImplicitConversion,
Schema = "dbo",
IsComposable = true,
IsNiladic = false,
IsBuiltIn = false,
IsAggregate = false,
IsFromProviderManifest = true,
StoreFunctionName = "StoredAddFunction",
ReturnParameters = new[]
{
FunctionParameter.Create("ReturnType", edmType, ParameterMode.ReturnValue)
},
Parameters = new[]
{
FunctionParameter.Create("Value1", edmType, ParameterMode.In),
FunctionParameter.Create("Value2", edmType, ParameterMode.In)
}
};
var myFunc = EdmFunction.Create("ClrStoredAddFunction", "BloggingContext", DataSpace.SSpace, payload, null);
dbModel.StoreModel.AddItem(myFunc);
var compiledModel = dbModel.Compile();
return(compiledModel);
}
private static void CreateReturnParameters(DbModel model, FunctionDescriptor functionImport,
out FunctionParameter[] returnParameters, out EntitySet[] entitySets)
{
var resultCount = functionImport.ReturnTypes.Count();
entitySets = new EntitySet[resultCount];
returnParameters = new FunctionParameter[resultCount];
for (int i = 0; i < resultCount; i++)
{
var returnType = functionImport.ReturnTypes[i];
if (returnType.BuiltInTypeKind == BuiltInTypeKind.EntityType)
{
var types = Tools.GetTypeHierarchy(returnType);
var matchingEntitySets =
model.ConceptualModel.Container.EntitySets
.Where(s => types.Contains(s.ElementType))
.ToArray();
if (matchingEntitySets.Length == 0)
{
throw new InvalidOperationException(
string.Format(
"The model does not contain EntitySet for the '{0}' entity type.",
returnType.FullName));
}
Debug.Assert(matchingEntitySets.Length == 1, "Invalid model (MEST)");
entitySets[i] = matchingEntitySets[0];
}
returnParameters[i] = FunctionParameter.Create(
"ReturnParam" + i,
returnType.GetCollectionType(),
ParameterMode.ReturnValue);
}
}
static EdmFunction CreateComposableEdmFunction([NotNull] MethodInfo method, [NotNull] DbFunctionAttribute dbFunctionInfo)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (dbFunctionInfo == null)
{
throw new ArgumentNullException(nameof(dbFunctionInfo));
}
return(EdmFunction.Create(
dbFunctionInfo.FunctionName,
dbFunctionInfo.NamespaceName,
DataSpace.SSpace,
new EdmFunctionPayload
{
ParameterTypeSemantics = ParameterTypeSemantics.AllowImplicitConversion,
Schema = string.Empty,
IsBuiltIn = true,
IsAggregate = false,
IsFromProviderManifest = true,
StoreFunctionName = dbFunctionInfo.FunctionName,
IsComposable = true,
ReturnParameters = new[]
{
FunctionParameter.Create(
"ReturnType",
MapTypeToEdmType(method.ReturnType),
ParameterMode.ReturnValue)
},
Parameters = method.GetParameters().Select(
x => FunctionParameter.Create(
x.Name,
MapTypeToEdmType(x.ParameterType),
ParameterMode.In)).ToList()
},
new List <MetadataProperty>()));
}
public IErrorReporter ErrorTestingValueType()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
GlobalVariables = true,
RelaxedMode = true,
DiscardingAnyExpressionDuringTests = true
}.SetMutability(mutability));
var root_ns = env.Root;
var system_ns = env.SystemNamespace;
IsType is_type = IsType.Create(NameReference.Create("foo"), NameFactory.RealNameReference());
var decl_src = VariableDeclaration.CreateStatement("foo", NameFactory.IObjectNameReference(), initValue: Undef.Create(), modifier: EntityModifier.Public);
var decl_dst = VariableDeclaration.CreateStatement("bar", null, initValue: is_type, modifier: EntityModifier.Public);
root_ns.AddNode(decl_src);
root_ns.AddNode(decl_dst);
IsType is_type_ref = IsType.Create(NameReference.Create("u"), NameFactory.ISequenceNameReference("G"));
root_ns.AddBuilder(FunctionBuilder.Create("more", "G", VarianceMode.None,
NameFactory.UnitNameReference(),
Block.CreateStatement(
ExpressionFactory.Readout(is_type_ref)
))
.Parameters(FunctionParameter.Create("u", NameFactory.ReferenceNameReference(
NameFactory.ISequenceNameReference("G", mutability: TypeMutability.ReadOnly)))));
resolver = NameResolver.Create(env);
Assert.AreEqual(2, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.IsTypeOfKnownTypes, is_type));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.IsTypeOfKnownTypes, is_type_ref));
}
return(resolver);
}
public EdmFunction Create(FunctionDescriptor functionDescriptor)
{
Debug.Assert(functionDescriptor != null, "functionDescriptor is null");
if (_schema == null && functionDescriptor.DatabaseSchema == null)
{
throw new InvalidOperationException(
string.Format(
"Database schema is not defined for function '{0}'. Either set a default database schema or use the DbFunctionEx attribute with non-null DatabaseSchema value.",
functionDescriptor.Name));
}
var functionPayload =
new EdmFunctionPayload
{
Parameters = functionDescriptor
.Parameters
.Select(
p => FunctionParameter.Create(
p.Name,
GetStorePrimitiveType(p),
p.IsOutParam
? ParameterMode.InOut
: ParameterMode.In)).ToArray(),
ReturnParameters = CreateFunctionReturnParameters(functionDescriptor),
IsComposable = functionDescriptor.StoreFunctionKind != StoreFunctionKind.StoredProcedure,
Schema = functionDescriptor.DatabaseSchema ?? _schema,
IsBuiltIn = functionDescriptor.IsBuiltIn,
IsNiladic = functionDescriptor.IsNiladic
};
return(EdmFunction.Create(
functionDescriptor.Name,
_namespace,
DataSpace.SSpace,
functionPayload,
null));
}
public void Apply(EntityContainer item, DbModel model)
{
var customFuncStore = EdmFunction.Create("MyCustomFunc", "SqlServer", DataSpace.SSpace, new EdmFunctionPayload
{
ParameterTypeSemantics = ParameterTypeSemantics.AllowImplicitConversion,
IsComposable = true,
IsAggregate = false,
StoreFunctionName = "MyCustomFunc",
IsBuiltIn = false,
ReturnParameters = new[]
{
FunctionParameter.Create("ReturnType", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32), ParameterMode.ReturnValue)
},
Parameters = new[]
{
FunctionParameter.Create("input", PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String), ParameterMode.In),
}
}, null);
model.StoreModel.AddItem(customFuncStore);
}
public IInterpreter PointerArgumentAutoDereference()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DebugThrowOnError = true,
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
var inc_def = root_ns.AddBuilder(FunctionBuilder.Create(
"inc",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
Return.Create(ExpressionFactory.Add(NameReference.Create("n"), Int64Literal.Create("1")))
}))
.Parameters(FunctionParameter.Create("n", NameFactory.Int64NameReference())));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("p_int", NameFactory.PointerNameReference(NameFactory.Int64NameReference()),
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), FunctionArgument.Create(Int64Literal.Create("1")))),
Return.Create(FunctionCall.Create(NameReference.Create("inc"), FunctionArgument.Create(NameReference.Create("p_int")))),
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
/*private TypeBuilder WithBaseEnum(string typename)
* {
* if (this.build != null)
* throw new InvalidOperationException();
*
* NameReference typename_ref = NameReference.Create(typename);
* this.embedTypeNames.Add(typename_ref);
* this.With(FunctionDefinition.CreateInitConstructor(EntityModifier.Native | EntityModifier.Implicit,
* new[] { FunctionParameter.Create(NameFactory.SourceConvConstructorParameter, typename_ref,
* ExpressionReadMode.CannotBeRead) },
* Block.CreateStatement()));
*
* return this;
* }*/
public static TypeBuilder CreateEnum(string name)
{
TypeBuilder builder = new TypeBuilder(NameDefinition.Create(name));
builder = builder
.SetModifier(EntityModifier.Enum)
.Parents(NameFactory.IEquatableNameReference())
.With(FunctionDefinition.CreateInitConstructor(EntityModifier.Native | EntityModifier.Private,
new[] { FunctionParameter.Create(NameFactory.EnumConstructorParameter, NameFactory.NatNameReference(),
ExpressionReadMode.CannotBeRead) },
Block.CreateStatement()))
// copy constructor
.With(FunctionDefinition.CreateInitConstructor(EntityModifier.Native,
new[] { FunctionParameter.Create(NameFactory.SourceCopyConstructorParameter, NameReference.Create(name),
ExpressionReadMode.CannotBeRead) },
Block.CreateStatement()))
.With(FunctionBuilder.Create(NameFactory.ConvertFunctionName, ExpressionReadMode.ReadRequired, NameFactory.NatNameReference(),
Block.CreateStatement())
.SetModifier(EntityModifier.Native))
// when enum inherits an enum it won't call super to check equality
.WithEquatableEquals(EntityModifier.UnchainBase)
.With(FunctionBuilder.Create(NameFactory.EqualOperator,
ExpressionReadMode.ReadRequired, NameFactory.BoolNameReference(),
Block.CreateStatement(new[] {
Return.Create(Undef.Create())
}))
.SetModifier(EntityModifier.Native)
.Parameters(FunctionParameter.Create("cmp", builder.CreateTypeNameReference(TypeMutability.ReadOnly), ExpressionReadMode.CannotBeRead)))
.With(FunctionBuilder.Create(NameFactory.NotEqualOperator,
ExpressionReadMode.ReadRequired, NameFactory.BoolNameReference(),
Block.CreateStatement(new[] {
Return.Create(Undef.Create())
}))
.SetModifier(EntityModifier.Native)
.Parameters(FunctionParameter.Create("cmp", builder.CreateTypeNameReference(TypeMutability.ReadOnly), ExpressionReadMode.CannotBeRead)))
;
return(builder);
}
/// <summary>
/// Applies the specified item.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="model">The model.</param>
public void Apply(EdmModel item, DbModel model)
{
var personIdParameter = FunctionParameter.Create(
"PersonId",
model.GetStorePrimitiveType(PrimitiveTypeKind.Int32),
ParameterMode.In);
var groupTypeIdParameter = FunctionParameter.Create(
"GroupTypeId",
model.GetStorePrimitiveType(PrimitiveTypeKind.Int32),
ParameterMode.In);
var returnValue = FunctionParameter.Create(
"result",
model.GetStorePrimitiveType(PrimitiveTypeKind.String),
ParameterMode.ReturnValue);
var function = item.CreateAndAddFunction(
"ufnGroup_GetGeofencingGroupNames",
new[] { personIdParameter, groupTypeIdParameter },
new[] { returnValue });
}
public IErrorReporter ProperBasicMethodOverride()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("IX")
.With(FunctionBuilder.CreateDeclaration(
"bar",
ExpressionReadMode.OptionalUse,
NameFactory.PointerNameReference(NameFactory.IObjectNameReference()))
.Parameters(FunctionParameter.Create("x", NameFactory.BoolNameReference(), Variadic.None, null, isNameRequired: false)))
.SetModifier(EntityModifier.Interface));
TypeDefinition type_impl = root_ns.AddBuilder(TypeBuilder.Create("X")
.With(FunctionBuilder.Create("bar",
ExpressionReadMode.OptionalUse,
// subtype of original result typename -- this is legal
NameFactory.PointerNameReference(NameFactory.Int64NameReference()),
Block.CreateStatement(new[] {
Return.Create(ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), Int64Literal.Create("2")))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.BoolNameReference(), usageMode: ExpressionReadMode.CannotBeRead))
.SetModifier(EntityModifier.Override))
.Parents(NameReference.Create("IX")));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
}
return(resolver);
}
public IInterpreter CommandLine()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat8NameReference(),
Block.CreateStatement(
ExpressionFactory.AssertEqual(StringLiteral.Create(Interpreter.Interpreter.CommandLineTestProgramPath),
NameReference.Create(NameFactory.CommandLineProgramPath)),
ExpressionFactory.AssertEqual(StringLiteral.Create(Interpreter.Interpreter.CommandLineTestArgument),
FunctionCall.Create(NameReference.Create(NameFactory.CommandLineArguments, NameFactory.AtFunctionName),
NatLiteral.Create("0"))),
Return.Create(Nat8Literal.Create("0"))
)).
Parameters(FunctionParameter.Create(NameFactory.CommandLineProgramPath,
NameFactory.StringPointerNameReference(TypeMutability.ReadOnly)),
FunctionParameter.Create(NameFactory.CommandLineArguments,
NameFactory.StringPointerNameReference(TypeMutability.ReadOnly), Variadic.Create(), null, isNameRequired: false)));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual((byte)0, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter ErrorHeapModifierOnOverride()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("Grandparent")
.SetModifier(EntityModifier.Base)
.With(FunctionBuilder.Create("f",
NameFactory.UnitNameReference(),
Block.CreateStatement())
.SetModifier(EntityModifier.Base)
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead))));
FunctionDefinition func = FunctionBuilder.Create("f",
NameFactory.UnitNameReference(),
Block.CreateStatement())
.SetModifier(EntityModifier.Override | EntityModifier.UnchainBase | EntityModifier.HeapOnly)
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead));
root_ns.AddBuilder(TypeBuilder.Create("Parent")
.SetModifier(EntityModifier.Base)
.Parents("Grandparent")
.With(func));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.HeapRequirementChangedOnOverride, func));
}
return(resolver);
}
// internal for testing
internal static FunctionParameter[] CreateFunctionImportParameters(SimpleMappingContext mappingContext, EdmFunction storeFunction)
{
Debug.Assert(mappingContext != null, "mappingContext != null");
Debug.Assert(storeFunction != null, "storeFunctionParameters != null");
var functionImportParameters = new FunctionParameter[storeFunction.Parameters.Count];
var uniqueParameterNames = new UniqueIdentifierService();
for (var idx = 0; idx < storeFunction.Parameters.Count; idx++)
{
Debug.Assert(storeFunction.Parameters[idx].Mode == ParameterMode.In, "Only In parameters are supported.");
var parameterName = CreateModelName(storeFunction.Parameters[idx].Name, uniqueParameterNames);
if (parameterName != storeFunction.Parameters[idx].Name)
{
mappingContext.Errors.Add(
new EdmSchemaError(
string.Format(
CultureInfo.InvariantCulture,
Resources_VersioningFacade.UnableToGenerateFunctionImportParameterName,
storeFunction.Parameters[idx].Name,
storeFunction.Name),
(int)ModelBuilderErrorCode.UnableToGenerateFunctionImportParameterName,
EdmSchemaErrorSeverity.Warning));
return(null);
}
functionImportParameters[idx] =
FunctionParameter.Create(
parameterName,
storeFunction.Parameters[idx].TypeUsage.ModelTypeUsage.EdmType,
storeFunction.Parameters[idx].Mode);
}
return(functionImportParameters);
}
public IErrorReporter ErrorConflictingOverlappingOptionalOverload()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), Variadic.None, null, false,
usageMode: ExpressionReadMode.CannotBeRead)));
root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), Variadic.None, Int64Literal.Create("3"), false,
usageMode: ExpressionReadMode.CannotBeRead)));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count());
Assert.AreEqual(ErrorCode.OverloadingDuplicateFunctionDefinition, resolver.ErrorManager.Errors.Single().Code);
}
return(resolver);
}
public IErrorReporter InferredTemplateArgumentsOnConstraints()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create("part",
TemplateParametersBuffer.Create("T", "X").Values,
NameFactory.UnitNameReference(),
Block.CreateStatement())
.Parameters(FunctionParameter.Create("x", NameReference.Create("T"), ExpressionReadMode.CannotBeRead))
.Constraints(ConstraintBuilder.Create("X")
.BaseOf(NameReference.Create("T"))));
FunctionCall call = FunctionCall.Create(NameReference.Create("part"), Int64Literal.Create("5"));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"caller",
NameFactory.UnitNameReference(),
Block.CreateStatement(new IExpression[] {
call
})));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
Assert.AreEqual(env.Int64Type.InstanceOf, call.Name.TemplateArguments[0].TypeName.Evaluation.Components);
Assert.AreEqual(env.Int64Type.InstanceOf, call.Name.TemplateArguments[1].TypeName.Evaluation.Components);
}
return(resolver);
}
public void Build_does_not_try_map_not_mapped_functions()
{
var rowTypeProperty = CreateStoreProperty("p1", "int");
var storeFunction = EdmFunction.Create(
"f_s",
"storeModel",
DataSpace.SSpace,
new EdmFunctionPayload
{
IsComposable = true,
IsFunctionImport = false,
ReturnParameters =
new[]
{
FunctionParameter.Create(
"ReturnType",
RowType.Create(new[] { rowTypeProperty }, null).GetCollectionType(),
ParameterMode.ReturnValue)
}
},
null);
var modelContainer = EntityContainer.Create("C_C", DataSpace.CSpace, new EntitySet[0], null, null);
var storeContainer = EntityContainer.Create("C_S", DataSpace.SSpace, new EntitySet[0], null, null);
var storeModel = EdmModel.CreateStoreModel(storeContainer, null, null);
storeModel.AddItem(storeFunction);
var mappingContext = new SimpleMappingContext(storeModel, true);
mappingContext.AddMapping(storeContainer, modelContainer);
var entityModel = DbDatabaseMappingBuilder.Build(mappingContext).ConceptualModel;
Assert.NotNull(entityModel);
Assert.Empty(entityModel.Containers.Single().FunctionImports);
}
private static EdmFunction CreateStoreFunction(DbModel model, FunctionDescriptor descriptor)
{
var parameters = descriptor.Parameters.Select(p =>
{
TypeUsage typeUsage = GetStoreTypeUsage(model, p);
return(FunctionParameter.Create(p.Name, typeUsage.EdmType,
p.Direction == ParameterDirection.Output ? ParameterMode.Out :
p.Direction == ParameterDirection.InputOutput ? ParameterMode.InOut :
p.Direction == ParameterDirection.ReturnValue ? ParameterMode.ReturnValue :
ParameterMode.In));
}).ToArray();
var results =
!descriptor.IsTableValued ?
descriptor.Results.Select(r => FunctionParameter.Create("Result", GetStoreTypeUsage(model, r).EdmType, ParameterMode.ReturnValue))
.ToArray() :
!descriptor.IsComposable.HasValue || descriptor.IsComposable.Value ?
descriptor.Results.Take(1).Select((r, i) => FunctionParameter.Create(string.Format("Result_{0}", i), CreateResultType(model, r).GetCollectionType(), ParameterMode.ReturnValue))
.ToArray() :
new FunctionParameter[0];
var payload = new EdmFunctionPayload
{
StoreFunctionName = descriptor.FunctionName,
IsFunctionImport = false,
IsAggregate = descriptor.IsAggregate,
IsBuiltIn = descriptor.IsBuiltIn,
IsComposable = descriptor.IsComposable,
IsNiladic = descriptor.IsNiladic,
ParameterTypeSemantics = descriptor.ParameterTypeSemantics,
Schema = descriptor.DatabaseSchema,
Parameters = parameters,
ReturnParameters = results,
};
return(EdmFunction.Create(descriptor.FunctionName, descriptor.NamespaceName, DataSpace.SSpace, payload, null));
}
public IErrorReporter ErrorReadingFunctionVoidResult()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
GlobalVariables = true,
RelaxedMode = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.CannotBeRead,
NameFactory.BoolNameReference(),
Block.CreateStatement(new[] {
Return.Create(BoolLiteral.CreateTrue())
}))
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), usageMode: ExpressionReadMode.CannotBeRead)));
root_ns.AddNode(VariableDeclaration.CreateStatement("i", NameFactory.Int64NameReference(), Undef.Create()));
var call = FunctionCall.Create(NameReference.Create("foo"), FunctionArgument.Create(NameReference.Create("i")));
VariableDeclaration decl = VariableDeclaration.CreateStatement("x", NameFactory.BoolNameReference(),
call, EntityModifier.Public);
root_ns.AddNode(decl);
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.CannotReadExpression, call));
}
return(resolver);
}
public IInterpreter UsingFunctionParameter()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
var inc_def = root_ns.AddBuilder(FunctionBuilder.Create(
"inc",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
Return.Create(FunctionCall.Create(NameReference.Create(NameReference.Create("n"), NameFactory.AddOperator),
FunctionArgument.Create(Int64Literal.Create("1"))))
}))
.Parameters(FunctionParameter.Create("n", NameFactory.Int64NameReference(), Variadic.None, null, isNameRequired: false)));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
Return.Create(FunctionCall.Create(NameReference.Create("inc"), FunctionArgument.Create(Int64Literal.Create("1"))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter ImplicitValueReferenceConversionOnCall()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.CannotBeRead,
NameFactory.UnitNameReference(),
Block.CreateStatement(new[] {
FunctionCall.Create(NameReference.Create("foo"), FunctionArgument.Create(Int64Literal.Create("5")))
})));
root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.CannotBeRead,
NameFactory.UnitNameReference(),
Block.CreateStatement())
.Parameters(FunctionParameter.Create("x", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()),
usageMode: ExpressionReadMode.CannotBeRead)));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
}
return(resolver);
}
public IErrorReporter ErrorNoDefaultConstructor()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
var bar_def = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Bar"))
.With(FunctionDefinition.CreateInitConstructor(EntityModifier.None,
new[] { FunctionParameter.Create("a", NameFactory.Int64NameReference(),
Variadic.None, null, isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead) },
Block.CreateStatement())));
VariableDeclaration field_decl = VariableDeclaration.CreateStatement("x", NameReference.Create("Bar"), null,
EntityModifier.Public);
var type_def = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Point"))
.With(field_decl));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.NoDefaultConstructor, field_decl));
}
return(resolver);
}
private static IList <FunctionParameter> GetModelReturnParameters(
this DbModel model, MethodInfo methodInfo, FunctionAttribute functionAttribute)
{
ParameterInfo returnParameterInfo = methodInfo.ReturnParameter;
if (returnParameterInfo == null || returnParameterInfo.ParameterType == typeof(void))
{
throw new NotSupportedException($"The return parameter type of {methodInfo.Name} is not supported.");
}
ParameterAttribute returnParameterAttribute = returnParameterInfo.GetCustomAttribute <ParameterAttribute>();
ResultTypeAttribute[] returnTypeAttributes = methodInfo.GetCustomAttributes <ResultTypeAttribute>().ToArray();
IEnumerable <EdmType> modelReturnParameterEdmTypes;
if (functionAttribute.Type == FunctionType.StoredProcedure)
{
if (returnParameterAttribute != null)
{
throw new NotSupportedException(
$"{nameof(ParameterAttribute)} for method {methodInfo.Name} is not supported.");
}
modelReturnParameterEdmTypes = methodInfo
.GetStoredProcedureReturnTypes()
.Select(clrType => model.GetModelStructualType(clrType, methodInfo));
}
else
{
if (returnTypeAttributes.Any())
{
throw new NotSupportedException(
$"{nameof(ResultTypeAttribute)} for method {methodInfo.Name} is not supported.");
}
if (functionAttribute.Type == FunctionType.TableValuedFunction)
{
// returnParameterInfo.ParameterType is IQueryable<T>.
Type returnParameterClrType = returnParameterInfo.ParameterType.GetGenericArguments().Single();
StructuralType modelReturnParameterStructuralType = model.GetModelStructualType(returnParameterClrType, methodInfo);
modelReturnParameterEdmTypes = Enumerable.Repeat(modelReturnParameterStructuralType, 1);
}
else
{
Type returnParameterClrType = returnParameterInfo.ParameterType;
Type returnParameterAttributeClrType = returnParameterAttribute?.ClrType;
if (returnParameterAttributeClrType != null &&
returnParameterAttributeClrType != returnParameterClrType)
{
throw new NotSupportedException(
$"Return parameter of method {methodInfo.Name} is of {returnParameterClrType.FullName}, but its {nameof(ParameterAttribute)}.{nameof(ParameterAttribute.ClrType)} has a different type {returnParameterAttributeClrType.FullName}");
}
PrimitiveType returnParameterPrimitiveType = model.GetModelPrimitiveType(returnParameterClrType, methodInfo);
modelReturnParameterEdmTypes = Enumerable.Repeat(returnParameterPrimitiveType, 1);
}
}
return(modelReturnParameterEdmTypes
.Select((edmType, index) => FunctionParameter.Create(
$"ReturnType{index}",
functionAttribute.Type == FunctionType.ModelDefinedFunction ? edmType : edmType.GetCollectionType(),
ParameterMode.ReturnValue))
.ToArray());
}
private static IList <FunctionParameter> GetStoreReturnParameters(
this DbModel model, MethodInfo methodInfo, FunctionAttribute functionAttribute)
{
ParameterInfo returnParameterInfo = methodInfo.ReturnParameter;
if (returnParameterInfo == null || returnParameterInfo.ParameterType == typeof(void))
{
throw new NotSupportedException($"The return type of {methodInfo.Name} is not supported.");
}
ParameterAttribute returnParameterAttribute = returnParameterInfo.GetCustomAttribute <ParameterAttribute>();
ResultTypeAttribute[] returnTypeAttributes = methodInfo.GetCustomAttributes <ResultTypeAttribute>().ToArray();
if (functionAttribute.Type == FunctionType.StoredProcedure)
{
if (returnParameterAttribute != null)
{
throw new NotSupportedException(
$"{nameof(ParameterAttribute)} for return value of method {methodInfo.Name} is not supported.");
}
return(new FunctionParameter[0]);
}
if (returnTypeAttributes.Any())
{
throw new NotSupportedException($"{nameof(ResultTypeAttribute)} for method {methodInfo.Name} is not supported.");
}
if (functionAttribute.Type == FunctionType.TableValuedFunction)
{
if (returnParameterAttribute != null)
{
throw new NotSupportedException(
$"{nameof(ParameterAttribute)} for return value of method {methodInfo.Name} is not supported.");
}
/*
* <CollectionType>
* <RowType>
* <Property Name="PersonID" Type="int" Nullable="false" />
* <Property Name="FirstName" Type="nvarchar" MaxLength="50" />
* <Property Name="LastName" Type="nvarchar" MaxLength="50" />
* <Property Name="JobTitle" Type="nvarchar" MaxLength="50" />
* <Property Name="BusinessEntityType" Type="nvarchar" MaxLength="50" />
* </RowType>
* </CollectionType>
*/
// returnParameterInfo.ParameterType is IQueryable<T>.
Type storeReturnParameterClrType = returnParameterInfo.ParameterType.GetGenericArguments().Single();
StructuralType modelReturnParameterStructuralType = model.GetModelStructualType(
storeReturnParameterClrType, methodInfo);
ComplexType modelReturnParameterComplexType = modelReturnParameterStructuralType as ComplexType;
RowType storeReturnParameterRowType;
if (modelReturnParameterComplexType != null)
{
storeReturnParameterRowType = RowType.Create(
modelReturnParameterComplexType.Properties.Select(property =>
EdmProperty.Create(property.Name, model.ProviderManifest.GetStoreType(property.TypeUsage))),
null);
}
else
{
EntityType modelReturnParameterEntityType = modelReturnParameterStructuralType as EntityType;
if (modelReturnParameterEntityType != null)
{
storeReturnParameterRowType = RowType.Create(
modelReturnParameterEntityType.Properties.Select(property =>
{
var typeUsage = TypeUsage.Create(model.ProviderManifest.GetStoreType(property.TypeUsage).EdmType, property.TypeUsage.Facets);
var result = EdmProperty.Create(property.Name, typeUsage);
var propertyNames = new[] { nameof(EdmProperty.Name), nameof(EdmProperty.TypeUsage), nameof(EdmProperty.MetadataProperties) };
result.SetMetadataProperties(property.MetadataProperties.Where(m => !propertyNames.Contains(m.Name)));
return(result);
}),
null);
//storeReturnParameterRowType = RowType.Create(
// modelReturnParameterEntityType.Properties.Select(property => property.Clone()),
// null);
}
else
{
throw new NotSupportedException($"Structural type {modelReturnParameterStructuralType.FullName} of method {methodInfo.Name} cannot be converted to {nameof(RowType)}.");
}
}
return(new FunctionParameter[]
{
FunctionParameter.Create(
"ReturnType",
storeReturnParameterRowType.GetCollectionType(), // Collection of RowType.
ParameterMode.ReturnValue)
});
}
if (functionAttribute.Type == FunctionType.NonComposableScalarValuedFunction)
{
// Non-composable scalar-valued function.
return(new FunctionParameter[0]);
}
// Composable scalar-valued/Aggregate/Built in/Niladic function.
// <Function Name="ufnGetProductListPrice" Aggregate="false" BuiltIn="false" NiladicFunction="false" IsComposable="true" ParameterTypeSemantics="AllowImplicitConversion" Schema="dbo"
// ReturnType ="money">
PrimitiveType storeReturnParameterPrimitiveType = model.GetStoreParameterPrimitiveType(methodInfo, returnParameterInfo, functionAttribute);
return(new FunctionParameter[]
{
FunctionParameter.Create("ReturnType", storeReturnParameterPrimitiveType, ParameterMode.ReturnValue)
});
}
public IInterpreter NoExtrasWithCopyConstructor()
{
// nothing is written in stone, but for now let's treat assignment in declaration as assignment
// not copy constructor (as in C++)
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("Point")
.SetModifier(EntityModifier.Mutable)
.With(FunctionBuilder.CreateInitConstructor(Block.CreateStatement()))
// copy-constructor
.With(FunctionBuilder.CreateInitConstructor(Block.CreateStatement(
Assignment.CreateStatement(NameReference.CreateThised("x"), Nat8Literal.Create("66"))
)).Parameters(FunctionParameter.Create("p", NameFactory.ReferenceNameReference("Point"),
ExpressionReadMode.CannotBeRead)))
.With(PropertyBuilder.Create(env.Options, "x", () => NameFactory.Nat8NameReference())
.With(VariableDeclaration.CreateStatement("f", NameFactory.Nat8NameReference(), null,
env.Options.ReassignableModifier()))
.WithGetter(Block.CreateStatement(Return.Create(NameReference.CreateThised("f"))))
.WithSetter(Block.CreateStatement(Assignment.CreateStatement(NameReference.CreateThised("f"),
ExpressionFactory.Mul(NameFactory.PropertySetterValueReference(), Nat8Literal.Create("2")))))));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat8NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("p", null,
ConstructorCall.StackConstructor(NameReference.Create("Point"))
.Init("x", Nat8Literal.Create("7"))
.Build()),
// bit-copy of the object, there is no calling copy-constructor here
VariableDeclaration.CreateStatement("r", null, NameReference.Create("p")),
Return.Create(NameReference.Create(NameReference.Create("r"), "x"))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual((byte)14, result.RetValue.PlainValue);
}
return(interpreter);
}
public void Can_create_composable_function_import_with_entity_type_hierarchy()
{
DbProviderManifest providerManifest;
var containerMapping = GetContainerMapping(out providerManifest);
var cTypeUsageInt = TypeUsage.Create(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.Int32),
new[]
{
Facet.Create(MetadataItem.NullableFacetDescription, false)
});
var sTypeUsageInt = TypeUsage.Create(
providerManifest.GetStoreType(cTypeUsageInt).EdmType,
new[]
{
Facet.Create(MetadataItem.NullableFacetDescription, false)
});
var cTypeUsageString = TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String));
var sTypeUsageString = providerManifest.GetStoreType(cTypeUsageString);
var itemCollection = containerMapping.StorageMappingItemCollection.EdmItemCollection.GetItems <EntityType>();
var baseEntityType = itemCollection.Single(et => et.Name == "E");
var entityType1 = itemCollection.Single(et => et.Name == "E1");
var entityType2 = itemCollection.Single(et => et.Name == "E2");
var rowType = RowType.Create(
new[]
{
EdmProperty.Create("CId", sTypeUsageInt),
EdmProperty.Create("C", sTypeUsageString),
EdmProperty.Create("C1", sTypeUsageString),
EdmProperty.Create("C2", sTypeUsageString),
EdmProperty.Create("CD", sTypeUsageString)
},
null);
var functionImport = EdmFunction.Create(
"F", "N", DataSpace.CSpace,
new EdmFunctionPayload
{
IsComposable = true,
ReturnParameters = new[]
{
FunctionParameter.Create("R", baseEntityType.GetCollectionType(), ParameterMode.ReturnValue)
}
},
null);
var targetFunction = EdmFunction.Create(
"SF", "N", DataSpace.SSpace,
new EdmFunctionPayload
{
IsComposable = true,
ReturnParameters = new[]
{
FunctionParameter.Create("R", rowType.GetCollectionType(), ParameterMode.ReturnValue)
}
},
null);
var resultMapping = new FunctionImportResultMapping();
var typeMapping = new FunctionImportEntityTypeMapping(
new[] { baseEntityType },
Enumerable.Empty <EntityType>(),
new Collection <FunctionImportReturnTypePropertyMapping>()
{
new FunctionImportReturnTypeScalarPropertyMapping("Id", "CId"),
new FunctionImportReturnTypeScalarPropertyMapping("P", "C"),
new FunctionImportReturnTypeScalarPropertyMapping("Discriminator", "CD"),
},
Enumerable.Empty <FunctionImportEntityTypeMappingConditionValue>());
resultMapping.AddTypeMapping(typeMapping);
typeMapping = new FunctionImportEntityTypeMapping(
Enumerable.Empty <EntityType>(),
new[] { entityType1 },
new Collection <FunctionImportReturnTypePropertyMapping>()
{
new FunctionImportReturnTypeScalarPropertyMapping("P1", "C1"),
},
new []
{
new FunctionImportEntityTypeMappingConditionValue("CD", "E1")
});
resultMapping.AddTypeMapping(typeMapping);
typeMapping = new FunctionImportEntityTypeMapping(
Enumerable.Empty <EntityType>(),
new[] { entityType2 },
new Collection <FunctionImportReturnTypePropertyMapping>()
{
new FunctionImportReturnTypeScalarPropertyMapping("P2", "C2"),
},
new []
{
new FunctionImportEntityTypeMappingConditionValue("CD", "E2")
});
resultMapping.AddTypeMapping(typeMapping);
var functionImportMapping = new FunctionImportMappingComposable(
functionImport,
targetFunction,
resultMapping,
containerMapping);
Assert.Same(resultMapping, functionImportMapping.ResultMapping);
Assert.Equal(2, functionImportMapping.StructuralTypeMappings.Count);
Assert.Equal(1, functionImportMapping.TvfKeys.Length);
Assert.Equal(typeof(E1).Name, functionImportMapping.StructuralTypeMappings[0].Item1.Name);
Assert.Equal(1, functionImportMapping.StructuralTypeMappings[0].Item2.Count());
Assert.Equal(3, functionImportMapping.StructuralTypeMappings[0].Item3.Count());
Assert.Equal(typeof(E2).Name, functionImportMapping.StructuralTypeMappings[1].Item1.Name);
Assert.Equal(1, functionImportMapping.StructuralTypeMappings[0].Item2.Count());
Assert.Equal(3, functionImportMapping.StructuralTypeMappings[0].Item3.Count());
}