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