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