/// <summary> /// Binds a 'concat' function to create a LINQ <see cref="Expression"/>. /// </summary> /// <param name="node">The query node to bind.</param> /// <param name="context">The query binder context.</param> /// <returns>The LINQ <see cref="Expression"/> created.</returns> protected virtual Expression BindConcat(SingleValueFunctionCallNode node, QueryBinderContext context) { CheckArgumentNull(node, context, "concat"); Expression[] arguments = BindArguments(node.Parameters, context); ValidateAllStringArguments(node.Name, arguments); Contract.Assert(arguments.Length == 2 && arguments[0].Type == typeof(string) && arguments[1].Type == typeof(string)); return(ExpressionBinderHelper.MakeFunctionCall(ClrCanonicalFunctions.Concat, context.QuerySettings, arguments)); }
/// <summary> /// Binds a 'substring' function to create a LINQ <see cref="Expression"/>. /// </summary> /// <param name="node">The query node to bind.</param> /// <param name="context">The query binder context.</param> /// <returns>The LINQ <see cref="Expression"/> created.</returns> protected virtual Expression BindSubstring(SingleValueFunctionCallNode node, QueryBinderContext context) { CheckArgumentNull(node, context, "substring"); Expression[] arguments = BindArguments(node.Parameters, context); if (arguments[0].Type != typeof(string)) { throw new ODataException(Error.Format(SRResources.FunctionNotSupportedOnEnum, node.Name)); } ODataQuerySettings querySettings = context.QuerySettings; Expression functionCall; if (arguments.Length == 2) { Contract.Assert(ExpressionBinderHelper.IsInteger(arguments[1].Type)); // When null propagation is allowed, we use a safe version of String.Substring(int). // But for providers that would not recognize custom expressions like this, we map // directly to String.Substring(int) if (context.QuerySettings.HandleNullPropagation == HandleNullPropagationOption.True) { // Safe function is static and takes string "this" as first argument functionCall = ExpressionBinderHelper.MakeFunctionCall(ClrCanonicalFunctions.SubstringStartNoThrow, querySettings, arguments); } else { functionCall = ExpressionBinderHelper.MakeFunctionCall(ClrCanonicalFunctions.SubstringStart, querySettings, arguments); } } else { // arguments.Length == 3 implies String.Substring(int, int) Contract.Assert(arguments.Length == 3 && ExpressionBinderHelper.IsInteger(arguments[1].Type) && ExpressionBinderHelper.IsInteger(arguments[2].Type)); // When null propagation is allowed, we use a safe version of String.Substring(int, int). // But for providers that would not recognize custom expressions like this, we map // directly to String.Substring(int, int) if (querySettings.HandleNullPropagation == HandleNullPropagationOption.True) { // Safe function is static and takes string "this" as first argument functionCall = ExpressionBinderHelper.MakeFunctionCall(ClrCanonicalFunctions.SubstringStartAndLengthNoThrow, querySettings, arguments); } else { functionCall = ExpressionBinderHelper.MakeFunctionCall(ClrCanonicalFunctions.SubstringStartAndLength, querySettings, arguments); } } return(functionCall); }
/// <summary> /// Binds 'ceiling' function to create a LINQ <see cref="Expression"/>. /// </summary> /// <param name="node">The query node to bind.</param> /// <param name="context">The query binder context.</param> /// <returns>The LINQ <see cref="Expression"/> created.</returns> protected virtual Expression BindCeiling(SingleValueFunctionCallNode node, QueryBinderContext context) { CheckArgumentNull(node, context, "ceiling"); Expression[] arguments = BindArguments(node.Parameters, context); Contract.Assert(arguments.Length == 1 && ExpressionBinderHelper.IsDoubleOrDecimal(arguments[0].Type)); MethodInfo ceiling = ExpressionBinderHelper.IsType <double>(arguments[0].Type) ? ClrCanonicalFunctions.CeilingOfDouble : ClrCanonicalFunctions.CeilingOfDecimal; return(ExpressionBinderHelper.MakeFunctionCall(ceiling, context.QuerySettings, arguments)); }
/// <summary> /// Binds customized function to create a LINQ <see cref="Expression"/>. /// </summary> /// <param name="node">The query node to bind.</param> /// <param name="context">The query binder context.</param> /// <returns>The LINQ <see cref="Expression"/> created.</returns> protected virtual Expression BindCustomMethodExpressionOrNull(SingleValueFunctionCallNode node, QueryBinderContext context) { CheckArgumentNull(node, context); Expression[] arguments = BindArguments(node.Parameters, context); IEnumerable <Type> methodArgumentsType = arguments.Select(argument => argument.Type); // Search for custom method info that are binded to the node name MethodInfo methodInfo; if (UriFunctionsBinder.TryGetMethodInfo(node.Name, methodArgumentsType, out methodInfo)) { return(ExpressionBinderHelper.MakeFunctionCall(methodInfo, context.QuerySettings, arguments)); } return(null); }
/// <summary> /// Binds time related functions to create a LINQ <see cref="Expression"/>. /// </summary> /// <param name="node">The query node to bind.</param> /// <param name="context">The query binder context.</param> /// <returns>The LINQ <see cref="Expression"/> created.</returns> protected virtual Expression BindTimeRelatedProperty(SingleValueFunctionCallNode node, QueryBinderContext context) { CheckArgumentNull(node, context); Expression[] arguments = BindArguments(node.Parameters, context); Contract.Assert(arguments.Length == 1 && ExpressionBinderHelper.IsTimeRelated(arguments[0].Type)); // We should support DateTime & DateTimeOffset even though DateTime is not part of OData v4 Spec. Expression parameter = arguments[0]; PropertyInfo property; if (ExpressionBinderHelper.IsTimeOfDay(parameter.Type)) { Contract.Assert(ClrCanonicalFunctions.TimeOfDayProperties.ContainsKey(node.Name)); property = ClrCanonicalFunctions.TimeOfDayProperties[node.Name]; } #if NET6_0 else if (parameter.Type.IsTimeOnly()) { Contract.Assert(ClrCanonicalFunctions.TimeOnlyProperties.ContainsKey(node.Name)); property = ClrCanonicalFunctions.TimeOnlyProperties[node.Name]; } #endif else if (ExpressionBinderHelper.IsDateTime(parameter.Type)) { Contract.Assert(ClrCanonicalFunctions.DateTimeProperties.ContainsKey(node.Name)); property = ClrCanonicalFunctions.DateTimeProperties[node.Name]; } else if (ExpressionBinderHelper.IsTimeSpan(parameter.Type)) { Contract.Assert(ClrCanonicalFunctions.TimeSpanProperties.ContainsKey(node.Name)); property = ClrCanonicalFunctions.TimeSpanProperties[node.Name]; } else { Contract.Assert(ClrCanonicalFunctions.DateTimeOffsetProperties.ContainsKey(node.Name)); property = ClrCanonicalFunctions.DateTimeOffsetProperties[node.Name]; } return(ExpressionBinderHelper.MakeFunctionCall(property, context.QuerySettings, parameter)); }