public virtual SqlExpression?Translate(
SqlExpression?instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
Check.NotNull(logger, nameof(logger));
if (method.Equals(_regexIsMatchMethodInfo))
{
var input = arguments[0];
var pattern = arguments[1];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(input, pattern);
return(_sqlExpressionFactory.Function(
"regexp",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(input, stringTypeMapping)
},
nullable: true,
argumentsPropagateNullability: new[] { true, true },
typeof(bool)));
}
return(null);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual SqlExpression?Translate(
SqlExpression?instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
if (method.Equals(MethodInfo))
{
var matchExpression = arguments[1];
var pattern = arguments[2];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(matchExpression, pattern);
return(_sqlExpressionFactory.Function(
"glob",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(matchExpression, stringTypeMapping)
},
nullable: true,
argumentsPropagateNullability: new[] { true, true },
typeof(bool)));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (_supportedMethods.TryGetValue(method, out var sqlFunctionName))
{
RelationalTypeMapping typeMapping;
List <SqlExpression> newArguments = null;
if (string.Equals(sqlFunctionName, "max") ||
string.Equals(sqlFunctionName, "max"))
{
typeMapping = ExpressionExtensions.InferTypeMapping(arguments[0], arguments[1]);
newArguments = new List <SqlExpression>
{
_sqlExpressionFactory.ApplyTypeMapping(arguments[0], typeMapping),
_sqlExpressionFactory.ApplyTypeMapping(arguments[1], typeMapping)
};
}
else
{
typeMapping = arguments[0].TypeMapping;
}
return(_sqlExpressionFactory.Function(
sqlFunctionName,
newArguments ?? arguments,
method.ReturnType,
typeMapping));
}
return(null);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual SqlExpression Translate(
SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments, IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
Check.NotNull(logger, nameof(logger));
if (_methodInfoDateDiffMapping.TryGetValue(method, out var datePart))
{
var startDate = arguments[1];
var endDate = arguments[2];
var typeMapping = ExpressionExtensions.InferTypeMapping(startDate, endDate);
startDate = _sqlExpressionFactory.ApplyTypeMapping(startDate, typeMapping);
endDate = _sqlExpressionFactory.ApplyTypeMapping(endDate, typeMapping);
return(_sqlExpressionFactory.Function(
"DATEDIFF",
new[] { _sqlExpressionFactory.Fragment(datePart), startDate, endDate },
nullable: true,
argumentsPropagateNullability: new[] { false, true, true },
typeof(int)));
}
return(null);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual SqlExpression Translate(
SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments, IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
Check.NotNull(logger, nameof(logger));
if (_supportedMethodTranslations.TryGetValue(method, out var sqlFunctionName))
{
var typeMapping = arguments.Count == 1
? ExpressionExtensions.InferTypeMapping(arguments[0])
: ExpressionExtensions.InferTypeMapping(arguments[0], arguments[1]);
var newArguments = new SqlExpression[arguments.Count];
newArguments[0] = _sqlExpressionFactory.ApplyTypeMapping(arguments[0], typeMapping);
if (arguments.Count == 2)
{
newArguments[1] = _sqlExpressionFactory.ApplyTypeMapping(arguments[1], typeMapping);
}
return(_sqlExpressionFactory.Function(
sqlFunctionName,
newArguments,
nullable: true,
argumentsPropagateNullability: newArguments.Select(a => true).ToArray(),
method.ReturnType,
sqlFunctionName == "SIGN" ? null : typeMapping));
}
if (_truncateMethodInfos.Contains(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"ROUND",
new[] { argument, _sqlExpressionFactory.Constant(0), _sqlExpressionFactory.Constant(1) },
nullable: true,
argumentsPropagateNullability: new[] { true, false, false },
method.ReturnType,
argument.TypeMapping));
}
if (_roundMethodInfos.Contains(method))
{
var argument = arguments[0];
var digits = arguments.Count == 2 ? arguments[1] : _sqlExpressionFactory.Constant(0);
return(_sqlExpressionFactory.Function(
"ROUND",
new[] { argument, digits },
nullable: true,
argumentsPropagateNullability: new[] { true, true },
method.ReturnType,
argument.TypeMapping));
}
return(null);
}
public SqlExpression Translate(
SqlExpression instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
// instance is null for static methods like Parse
const string storeType = SqlServerHierarchyIdTypeMappingSourcePlugin.SqlServerTypeName;
var callingType = instance?.Type ?? method.DeclaringType;
if (typeof(HierarchyId).IsAssignableFrom(callingType) &&
_methodToFunctionName.TryGetValue(method, out var functionName))
{
var typeMappedArguments = new List <SqlExpression>();
foreach (var argument in arguments)
{
var argumentTypeMapping = typeof(HierarchyId).IsAssignableFrom(argument.Type)
? _typeMappingSource.FindMapping(argument.Type, storeType)
: _typeMappingSource.FindMapping(argument.Type);
var mappedArgument = _sqlExpressionFactory.ApplyTypeMapping(argument, argumentTypeMapping);
typeMappedArguments.Add(mappedArgument);
}
var resultTypeMapping = typeof(HierarchyId).IsAssignableFrom(method.ReturnType)
? _typeMappingSource.FindMapping(method.ReturnType, storeType)
: _typeMappingSource.FindMapping(method.ReturnType);
if (instance != null)
{
var instanceMapping = _typeMappingSource.FindMapping(instance.Type, storeType);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, instanceMapping);
return(_sqlExpressionFactory.Function(
instance,
functionName,
simplify(arguments),
nullable: true,
instancePropagatesNullability: true,
argumentsPropagateNullability: arguments.Select(a => true),
method.ReturnType,
resultTypeMapping));
}
return(_sqlExpressionFactory.Function(
functionName,
simplify(arguments),
nullable: true,
argumentsPropagateNullability: arguments.Select(a => true),
method.ReturnType,
resultTypeMapping));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (_supportedMethodTranslations.TryGetValue(method, out var sqlFunctionName))
{
var typeMapping = arguments.Count == 1
? ExpressionExtensions.InferTypeMapping(arguments[0])
: ExpressionExtensions.InferTypeMapping(arguments[0], arguments[1]);
var newArguments = new SqlExpression[arguments.Count];
newArguments[0] = _sqlExpressionFactory.ApplyTypeMapping(arguments[0], typeMapping);
if (arguments.Count == 2)
{
newArguments[1] = _sqlExpressionFactory.ApplyTypeMapping(arguments[1], typeMapping);
}
return(_sqlExpressionFactory.Function(
sqlFunctionName,
newArguments,
method.ReturnType,
sqlFunctionName == "SIGN" ? null : typeMapping));
}
if (_truncateMethodInfos.Contains(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"ROUND",
new[] {
argument,
_sqlExpressionFactory.Constant(0),
_sqlExpressionFactory.Constant(1)
},
method.ReturnType,
argument.TypeMapping));
}
if (_roundMethodInfos.Contains(method))
{
var argument = arguments[0];
var digits = arguments.Count == 2 ? arguments[1] : _sqlExpressionFactory.Constant(0);
return(_sqlExpressionFactory.Function(
"ROUND",
new[] { argument, digits },
method.ReturnType,
argument.TypeMapping));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
if (_functionMapping.TryGetValue(method, out var functionName))
{
var propertyReference = arguments[1];
if (!(propertyReference is ColumnExpression))
{
throw new InvalidOperationException(SqlServerStrings.InvalidColumnNameForFreeText);
}
var typeMapping = propertyReference.TypeMapping;
var freeText = _sqlExpressionFactory.ApplyTypeMapping(arguments[2], typeMapping);
var functionArguments = new List <SqlExpression> {
propertyReference, freeText
};
if (arguments.Count == 4)
{
functionArguments.Add(
_sqlExpressionFactory.Fragment($"LANGUAGE {((SqlConstantExpression)arguments[3]).Value}"));
}
return(_sqlExpressionFactory.Function(
functionName,
functionArguments,
typeof(bool)));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (_functionMapping.TryGetValue(method, out var functionName))
{
var propertyReference = arguments[1];
if (!(propertyReference is ColumnExpression))
{
throw new InvalidOperationException("The 'FreeText' method is not supported because the query has switched to client-evaluation. Inspect the log to determine which query expressions are triggering client-evaluation.");
}
var typeMapping = propertyReference.TypeMapping;
var freeText = _sqlExpressionFactory.ApplyTypeMapping(arguments[2], typeMapping);
var functionArguments = new List <SqlExpression> {
propertyReference, freeText
};
if (arguments.Count == 4)
{
functionArguments.Add(
_sqlExpressionFactory.Fragment($"LANGUAGE {((SqlConstantExpression)arguments[3]).Value}"));
}
return(_sqlExpressionFactory.Function(
functionName,
functionArguments,
typeof(bool)));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (_methodInfoDateDiffMapping.TryGetValue(method, out var datePart))
{
var startDate = arguments[1];
var endDate = arguments[2];
var typeMapping = ExpressionExtensions.InferTypeMapping(startDate, endDate);
startDate = _sqlExpressionFactory.ApplyTypeMapping(startDate, typeMapping);
endDate = _sqlExpressionFactory.ApplyTypeMapping(endDate, typeMapping);
return(_sqlExpressionFactory.Function(
"DATEDIFF",
new[] { _sqlExpressionFactory.Fragment(datePart), startDate, endDate },
typeof(int)));
}
return(null);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual SqlExpression Translate(
SqlExpression instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
Check.NotNull(logger, nameof(logger));
if (_supportedMethods.TryGetValue(method, out var sqlFunctionName))
{
RelationalTypeMapping typeMapping;
List <SqlExpression> newArguments = null;
if (string.Equals(sqlFunctionName, "max") ||
string.Equals(sqlFunctionName, "max"))
{
typeMapping = ExpressionExtensions.InferTypeMapping(arguments[0], arguments[1]);
newArguments = new List <SqlExpression>
{
_sqlExpressionFactory.ApplyTypeMapping(arguments[0], typeMapping),
_sqlExpressionFactory.ApplyTypeMapping(arguments[1], typeMapping)
};
}
else
{
typeMapping = arguments[0].TypeMapping;
}
var finalArguments = newArguments ?? arguments;
return(_sqlExpressionFactory.Function(
sqlFunctionName,
finalArguments,
nullable: true,
argumentsPropagateNullability: finalArguments.Select(a => true).ToList(),
method.ReturnType,
typeMapping));
}
return(null);
}
public SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments, IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
if (_methodInfoDateDiffMapping.TryGetValue(method, out var datePart))
{
var startDate = arguments[1];
var endDate = arguments[2];
var typeMapping = ExpressionExtensions.InferTypeMapping(startDate, endDate);
startDate = _sqlExpressionFactory.ApplyTypeMapping(startDate, typeMapping);
endDate = _sqlExpressionFactory.ApplyTypeMapping(endDate, typeMapping);
return(_sqlExpressionFactory.Function(
"DATEDIFF",
new[] { _sqlExpressionFactory.Constant(datePart), startDate, endDate },
false,
new[] { false },
typeof(int)));
}
return(null);
}
public SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (method.DeclaringType != typeof(NpgsqlRangeExtensions))
{
return(null);
}
if (method.Name == nameof(NpgsqlRangeExtensions.Merge))
{
var inferredMapping = ExpressionExtensions.InferTypeMapping(arguments[0], arguments[1]);
return(_sqlExpressionFactory.Function(
"range_merge",
new[] {
_sqlExpressionFactory.ApplyTypeMapping(arguments[0], inferredMapping),
_sqlExpressionFactory.ApplyTypeMapping(arguments[1], inferredMapping)
},
method.ReturnType,
inferredMapping));
}
return(method.Name switch
{
nameof(NpgsqlRangeExtensions.Contains) when arguments[0].Type == arguments[1].Type => BoolReturningOnTwoRanges("@>"),
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual SqlExpression?Translate(
SqlExpression?instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
Check.NotNull(logger, nameof(logger));
if (_functionMapping.TryGetValue(method, out var functionName))
{
var propertyReference = arguments[1];
if (!(propertyReference is ColumnExpression))
{
throw new InvalidOperationException(SqlServerStrings.InvalidColumnNameForFreeText);
}
var typeMapping = propertyReference.TypeMapping;
var freeText = propertyReference.Type == arguments[2].Type
? _sqlExpressionFactory.ApplyTypeMapping(arguments[2], typeMapping)
: _sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[2]);
var functionArguments = new List <SqlExpression> {
propertyReference, freeText
};
if (arguments.Count == 4)
{
functionArguments.Add(
_sqlExpressionFactory.Fragment($"LANGUAGE {((SqlConstantExpression)arguments[3]).Value}"));
}
return(_sqlExpressionFactory.Function(
functionName,
functionArguments,
nullable: true,
// TODO: don't propagate for now
argumentsPropagateNullability: functionArguments.Select(a => false).ToList(),
typeof(bool)));
}
return(null);
}
private SqlExpression InferStringTypeMappingOrApplyDefault(SqlExpression expression, RelationalTypeMapping inferenceSourceTypeMapping)
{
if (expression == null)
{
return(null);
}
if (expression.TypeMapping != null)
{
return(expression);
}
if (expression.Type == typeof(string) && inferenceSourceTypeMapping?.ClrType == typeof(string))
{
return(_sqlExpressionFactory.ApplyTypeMapping(expression, inferenceSourceTypeMapping));
}
return(_sqlExpressionFactory.ApplyDefaultTypeMapping(expression));
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual SqlExpression?Translate(
SqlExpression?instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
if (instance != null)
{
if (IndexOfMethodInfo.Equals(method))
{
return(TranslateIndexOf(instance, method, arguments[0], null));
}
if (IndexOfMethodInfoWithStartingPosition.Equals(method))
{
return(TranslateIndexOf(instance, method, arguments[0], arguments[1]));
}
if (ReplaceMethodInfo.Equals(method))
{
var firstArgument = arguments[0];
var secondArgument = arguments[1];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, firstArgument, secondArgument);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
firstArgument = _sqlExpressionFactory.ApplyTypeMapping(firstArgument, stringTypeMapping);
secondArgument = _sqlExpressionFactory.ApplyTypeMapping(secondArgument, stringTypeMapping);
return(_sqlExpressionFactory.Function(
"REPLACE",
new[] { instance, firstArgument, secondArgument },
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType,
stringTypeMapping));
}
if (ToLowerMethodInfo.Equals(method) ||
ToUpperMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
ToLowerMethodInfo.Equals(method) ? "LOWER" : "UPPER",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
method.ReturnType,
instance.TypeMapping));
}
if (SubstringMethodInfoWithOneArg.Equals(method))
{
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[]
{
instance,
_sqlExpressionFactory.Add(
arguments[0],
_sqlExpressionFactory.Constant(1)),
_sqlExpressionFactory.Function(
"LEN",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
typeof(int))
},
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType,
instance.TypeMapping));
}
if (SubstringMethodInfoWithTwoArgs.Equals(method))
{
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[]
{
instance,
_sqlExpressionFactory.Add(
arguments[0],
_sqlExpressionFactory.Constant(1)),
arguments[1]
},
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType,
instance.TypeMapping));
}
if (TrimStartMethodInfoWithoutArgs?.Equals(method) == true ||
(TrimStartMethodInfoWithCharArrayArg.Equals(method)
// SqlServer LTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"LTRIM",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping));
}
if (TrimEndMethodInfoWithoutArgs?.Equals(method) == true ||
(TrimEndMethodInfoWithCharArrayArg.Equals(method)
// SqlServer RTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"RTRIM",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping));
}
if (TrimMethodInfoWithoutArgs?.Equals(method) == true ||
(TrimMethodInfoWithCharArrayArg.Equals(method)
// SqlServer LTRIM/RTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"LTRIM",
new[]
{
_sqlExpressionFactory.Function(
"RTRIM",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping)
},
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping));
}
if (ContainsMethodInfo.Equals(method))
{
var pattern = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, pattern);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
pattern = _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping);
if (pattern is SqlConstantExpression constantPattern)
{
if (!(constantPattern.Value is string patternValue))
{
return(_sqlExpressionFactory.Like(
instance,
_sqlExpressionFactory.Constant(null, stringTypeMapping)));
}
if (patternValue.Length == 0)
{
return(_sqlExpressionFactory.Constant(true));
}
return(patternValue.Any(IsLikeWildChar)
? _sqlExpressionFactory.Like(
instance,
_sqlExpressionFactory.Constant($"%{EscapeLikePattern(patternValue)}%"),
_sqlExpressionFactory.Constant(LikeEscapeString))
: _sqlExpressionFactory.Like(instance, _sqlExpressionFactory.Constant($"%{patternValue}%")));
}
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.Like(
pattern,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
_sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"CHARINDEX",
new[] { pattern, instance },
nullable: true,
argumentsPropagateNullability: new[] { true, true },
typeof(int)),
_sqlExpressionFactory.Constant(0))));
}
if (StartsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], true));
}
if (EndsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], false));
}
}
if (IsNullOrEmptyMethodInfo.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Like(
argument,
_sqlExpressionFactory.Constant(string.Empty))));
}
if (IsNullOrWhiteSpaceMethodInfo.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Equal(
argument,
_sqlExpressionFactory.Constant(string.Empty, argument.TypeMapping))));
}
if (FirstOrDefaultMethodInfoWithoutArgs.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[] { argument, _sqlExpressionFactory.Constant(1), _sqlExpressionFactory.Constant(1) },
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType));
}
if (LastOrDefaultMethodInfoWithoutArgs.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[]
{
argument,
_sqlExpressionFactory.Function(
"LEN",
new[] { argument },
nullable: true,
argumentsPropagateNullability: new[] { true },
typeof(int)),
_sqlExpressionFactory.Constant(1)
},
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
if (_indexOfMethodInfo.Equals(method))
{
var argument = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, argument);
argument = _sqlExpressionFactory.ApplyTypeMapping(argument, stringTypeMapping);
SqlExpression charIndexExpression;
var storeType = stringTypeMapping.StoreType;
if (string.Equals(storeType, "nvarchar(max)", StringComparison.OrdinalIgnoreCase) ||
string.Equals(storeType, "varchar(max)", StringComparison.OrdinalIgnoreCase))
{
charIndexExpression = _sqlExpressionFactory.Function(
"CHARINDEX",
new[] { argument, _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping) },
nullable: true,
argumentsPropagateNullability: new [] { true, true },
typeof(long));
charIndexExpression = _sqlExpressionFactory.Convert(charIndexExpression, typeof(int));
}
else
{
charIndexExpression = _sqlExpressionFactory.Function(
"CHARINDEX",
new[] { argument, _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping) },
nullable: true,
argumentsPropagateNullability: new[] { true, true },
method.ReturnType);
}
charIndexExpression = _sqlExpressionFactory.Subtract(charIndexExpression, _sqlExpressionFactory.Constant(1));
return(_sqlExpressionFactory.Case(
new[]
{
new CaseWhenClause(
_sqlExpressionFactory.Equal(
argument,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
_sqlExpressionFactory.Constant(0))
},
charIndexExpression));
}
if (_replaceMethodInfo.Equals(method))
{
var firstArgument = arguments[0];
var secondArgument = arguments[1];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, firstArgument, secondArgument);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
firstArgument = _sqlExpressionFactory.ApplyTypeMapping(firstArgument, stringTypeMapping);
secondArgument = _sqlExpressionFactory.ApplyTypeMapping(secondArgument, stringTypeMapping);
return(_sqlExpressionFactory.Function(
"REPLACE",
new[] { instance, firstArgument, secondArgument },
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType,
stringTypeMapping));
}
if (_toLowerMethodInfo.Equals(method) ||
_toUpperMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
_toLowerMethodInfo.Equals(method) ? "LOWER" : "UPPER",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
method.ReturnType,
instance.TypeMapping));
}
if (_substringMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[]
{
instance,
_sqlExpressionFactory.Add(
arguments[0],
_sqlExpressionFactory.Constant(1)),
arguments[1]
},
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType,
instance.TypeMapping));
}
if (_isNullOrWhiteSpaceMethodInfo.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Equal(
_sqlExpressionFactory.Function(
"LTRIM",
new[]
{
_sqlExpressionFactory.Function(
"RTRIM",
new[] { argument },
nullable: true,
argumentsPropagateNullability: new[] { true },
argument.Type,
argument.TypeMapping)
},
nullable: true,
argumentsPropagateNullability: new[] { true },
argument.Type,
argument.TypeMapping),
_sqlExpressionFactory.Constant(string.Empty, argument.TypeMapping))));
}
if (_trimStartMethodInfoWithoutArgs?.Equals(method) == true ||
(_trimStartMethodInfoWithCharArrayArg.Equals(method)
// SqlServer LTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"LTRIM",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping));
}
if (_trimEndMethodInfoWithoutArgs?.Equals(method) == true ||
(_trimEndMethodInfoWithCharArrayArg.Equals(method)
// SqlServer RTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"RTRIM",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping));
}
if (_trimMethodInfoWithoutArgs?.Equals(method) == true ||
(_trimMethodInfoWithCharArrayArg.Equals(method)
// SqlServer LTRIM/RTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"LTRIM",
new[]
{
_sqlExpressionFactory.Function(
"RTRIM",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping)
},
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping));
}
if (_containsMethodInfo.Equals(method))
{
var pattern = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, pattern);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
pattern = _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping);
if (pattern is SqlConstantExpression constantPattern)
{
// Intentionally string.Empty since we don't want to match nulls here.
#pragma warning disable CA1820 // Test for empty strings using string length
if ((string)constantPattern.Value == string.Empty)
#pragma warning restore CA1820 // Test for empty strings using string length
{
return(_sqlExpressionFactory.Constant(true));
}
return(_sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"CHARINDEX",
new[] { pattern, instance },
nullable: true,
argumentsPropagateNullability: new[] { true, true },
typeof(int)),
_sqlExpressionFactory.Constant(0)));
}
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.Equal(
pattern,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
_sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"CHARINDEX",
new[] { pattern, instance },
nullable: true,
argumentsPropagateNullability: new[] { true, true },
typeof(int)),
_sqlExpressionFactory.Constant(0))));
}
if (_startsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], true));
}
if (_endsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], false));
}
return(null);
}
public virtual SqlExpression Translate(
SqlExpression instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
if (method == IndexOfString || method == IndexOfChar)
{
var argument = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, argument);
return(_sqlExpressionFactory.Subtract(
_sqlExpressionFactory.Function(
"strpos",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(argument, stringTypeMapping)
},
nullable: true,
argumentsPropagateNullability: TrueArrays[2],
method.ReturnType),
_sqlExpressionFactory.Constant(1)));
}
if (method == Replace)
{
var oldValue = arguments[0];
var newValue = arguments[1];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, oldValue, newValue);
return(_sqlExpressionFactory.Function(
"replace",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(oldValue, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(newValue, stringTypeMapping)
},
nullable: true,
argumentsPropagateNullability: TrueArrays[3],
method.ReturnType,
stringTypeMapping));
}
if (method == ToLower || method == ToUpper)
{
return(_sqlExpressionFactory.Function(
method == ToLower ? "lower" : "upper",
new[] { instance },
nullable: true,
argumentsPropagateNullability: TrueArrays[1],
method.ReturnType,
instance.TypeMapping));
}
if (method == Substring || method == SubstringWithLength)
{
var args =
method == Substring
? new[] { instance, GenerateOneBasedIndexExpression(arguments[0]) }
: new[] { instance, GenerateOneBasedIndexExpression(arguments[0]), arguments[1] };
return(_sqlExpressionFactory.Function(
"substring",
args,
nullable: true,
argumentsPropagateNullability: TrueArrays[args.Length],
method.ReturnType,
instance.TypeMapping));
}
if (method == IsNullOrWhiteSpace)
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Equal(
_sqlExpressionFactory.Function(
"btrim",
new[]
{
argument,
_whitespace
},
nullable: true,
argumentsPropagateNullability: TrueArrays[2],
argument.Type,
argument.TypeMapping),
_sqlExpressionFactory.Constant(string.Empty, argument.TypeMapping))));
}
var isTrimStart = method == TrimStartWithNoParam || method == TrimStartWithChars || method == TrimStartWithSingleChar;
var isTrimEnd = method == TrimEndWithNoParam || method == TrimEndWithChars || method == TrimEndWithSingleChar;
var isTrimBoth = method == TrimBothWithNoParam || method == TrimBothWithChars || method == TrimBothWithSingleChar;
if (isTrimStart || isTrimEnd || isTrimBoth)
{
char[] trimChars = null;
if (method == TrimStartWithChars || method == TrimStartWithSingleChar ||
method == TrimEndWithChars || method == TrimEndWithSingleChar ||
method == TrimBothWithChars || method == TrimBothWithSingleChar)
{
var constantTrimChars = arguments[0] as SqlConstantExpression;
if (constantTrimChars == null)
{
return(null); // Don't translate if trim chars isn't a constant
}
trimChars = constantTrimChars.Value is char c
? new[] { c }
: (char[])constantTrimChars.Value;
}
return(_sqlExpressionFactory.Function(
isTrimStart ? "ltrim" : isTrimEnd ? "rtrim" : "btrim",
new[]
{
instance,
trimChars == null || trimChars.Length == 0
? _whitespace
: _sqlExpressionFactory.Constant(new string(trimChars))
},
nullable: true,
argumentsPropagateNullability: TrueArrays[2],
instance.Type,
instance.TypeMapping));
}
if (method == Contains)
{
var pattern = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, pattern);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
pattern = _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping);
var strposCheck = _sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"strpos",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping)
},
nullable: true,
argumentsPropagateNullability: TrueArrays[2],
typeof(int)),
_sqlExpressionFactory.Constant(0));
if (pattern is SqlConstantExpression constantPattern)
{
return((string)constantPattern.Value == string.Empty
? (SqlExpression)_sqlExpressionFactory.Constant(true)
: strposCheck);
}
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.Equal(
pattern,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
strposCheck));
}
if (method == PadLeft || method == PadLeftWithChar || method == PadRight || method == PadRightWithChar)
{
var args =
method == PadLeft || method == PadRight
? new[] { instance, arguments[0] }
: new[] { instance, arguments[0], arguments[1] };
return(_sqlExpressionFactory.Function(
method == PadLeft || method == PadLeftWithChar ? "lpad" : "rpad",
args,
nullable: true,
argumentsPropagateNullability: TrueArrays[args.Length],
instance.Type,
instance.TypeMapping));
}
if (method == FirstOrDefaultMethodInfoWithoutArgs)
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"substr",
new[] { argument, _sqlExpressionFactory.Constant(1), _sqlExpressionFactory.Constant(1) },
nullable: true,
argumentsPropagateNullability: TrueArrays[3],
method.ReturnType));
}
if (method == LastOrDefaultMethodInfoWithoutArgs)
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"substr",
new[]
{
argument,
_sqlExpressionFactory.Function(
"length",
new[] { argument },
nullable: true,
argumentsPropagateNullability: new[] { true },
typeof(int)),
_sqlExpressionFactory.Constant(1)
},
nullable: true,
argumentsPropagateNullability: TrueArrays[3],
method.ReturnType));
}
if (method == DbFunctionsReverse)
{
return(_sqlExpressionFactory.Function(
"reverse",
new[] { arguments[1] },
nullable: true,
argumentsPropagateNullability: TrueArrays[1],
typeof(string),
arguments[1].TypeMapping));
}
if (method == StartsWith)
{
return(TranslateStartsEndsWith(instance, arguments[0], true));
}
if (method == EndsWith)
{
return(TranslateStartsEndsWith(instance, arguments[0], false));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (typeof(Geometry).IsAssignableFrom(method.DeclaringType))
{
var geometryExpressions = new[] { instance }.Concat(
arguments.Where(e => typeof(Geometry).IsAssignableFrom(e.Type)));
var typeMapping = ExpressionExtensions.InferTypeMapping(geometryExpressions.ToArray());
Debug.Assert(typeMapping != null, "At least one argument must have typeMapping.");
var storeType = typeMapping.StoreType;
if (_methodToFunctionName.TryGetValue(method, out var functionName) ||
_geometryMethodToFunctionName.TryGetValue(method, out functionName))
{
instance = _sqlExpressionFactory.ApplyTypeMapping(
instance,
_typeMappingSource.FindMapping(instance.Type, storeType));
var typeMappedArguments = new List <SqlExpression>
{
instance
};
foreach (var argument in arguments)
{
typeMappedArguments.Add(
_sqlExpressionFactory.ApplyTypeMapping(
argument,
typeof(Geometry).IsAssignableFrom(argument.Type)
? _typeMappingSource.FindMapping(argument.Type, storeType)
: _typeMappingSource.FindMapping(argument.Type)));
}
var resultTypeMapping = typeof(Geometry).IsAssignableFrom(method.ReturnType)
? _typeMappingSource.FindMapping(method.ReturnType, storeType)
: _typeMappingSource.FindMapping(method.ReturnType);
return(_sqlExpressionFactory.Function(
functionName,
typeMappedArguments,
method.ReturnType,
resultTypeMapping));
}
if (Equals(method, _getGeometryN))
{
return(_sqlExpressionFactory.Function(
"ST_GeometryN",
new[]
{
instance,
_sqlExpressionFactory.Add(
arguments[0],
_sqlExpressionFactory.Constant(1))
},
method.ReturnType,
_typeMappingSource.FindMapping(method.ReturnType, storeType)));
}
if (Equals(method, _distance))
{
return(GetDistanceCallBySrid(
instance,
arguments[0],
method.ReturnType,
_typeMappingSource.FindMapping(method.ReturnType, storeType)));
}
if (Equals(method, _isWithinDistance))
{
return(_sqlExpressionFactory.LessThanOrEqual(
GetDistanceCallBySrid(
instance,
arguments[0],
_distance.ReturnType,
_typeMappingSource.FindMapping(_distance.ReturnType)),
arguments[1]));
}
}
return(null);
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual SqlExpression?Translate(
SqlExpression?instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
Check.NotNull(logger, nameof(logger));
if (typeof(Geometry).IsAssignableFrom(method.DeclaringType) &&
instance != null)
{
var geometryExpressions = new[] { instance }.Concat(
arguments.Where(e => typeof(Geometry).IsAssignableFrom(e.Type)));
var typeMapping = ExpressionExtensions.InferTypeMapping(geometryExpressions.ToArray());
Check.DebugAssert(typeMapping != null, "At least one argument must have typeMapping.");
var storeType = typeMapping.StoreType;
var isGeography = string.Equals(storeType, "geography", StringComparison.OrdinalIgnoreCase);
if (_methodToFunctionName.TryGetValue(method, out var functionName) ||
(!isGeography && _geometryMethodToFunctionName.TryGetValue(method, out functionName)))
{
instance = _sqlExpressionFactory.ApplyTypeMapping(
instance, _typeMappingSource.FindMapping(instance.Type, storeType));
var typeMappedArguments = new List <SqlExpression>();
foreach (var argument in arguments)
{
typeMappedArguments.Add(
_sqlExpressionFactory.ApplyTypeMapping(
argument,
typeof(Geometry).IsAssignableFrom(argument.Type)
? _typeMappingSource.FindMapping(argument.Type, storeType)
: _typeMappingSource.FindMapping(argument.Type)));
}
var resultTypeMapping = typeof(Geometry).IsAssignableFrom(method.ReturnType)
? _typeMappingSource.FindMapping(method.ReturnType, storeType)
: _typeMappingSource.FindMapping(method.ReturnType);
var finalArguments = Simplify(typeMappedArguments, isGeography);
var argumentsPropagateNullability = functionName == "STBuffer"
? new[] { false }
: functionName == "STRelate"
? new[] { true, false }
: finalArguments.Select(a => true).ToArray();
return(_sqlExpressionFactory.Function(
instance,
functionName,
finalArguments,
nullable: true,
instancePropagatesNullability: true,
argumentsPropagateNullability,
method.ReturnType,
resultTypeMapping));
}
if (Equals(method, _getGeometryN))
{
return(_sqlExpressionFactory.Function(
instance,
"STGeometryN",
new[]
{
_sqlExpressionFactory.Add(
arguments[0],
_sqlExpressionFactory.Constant(1))
},
nullable: true,
instancePropagatesNullability: true,
argumentsPropagateNullability: new[] { false },
method.ReturnType,
_typeMappingSource.FindMapping(method.ReturnType, storeType)));
}
if (Equals(method, _isWithinDistance))
{
instance = _sqlExpressionFactory.ApplyTypeMapping(
instance, _typeMappingSource.FindMapping(instance.Type, storeType));
var typeMappedArguments = new List <SqlExpression>();
foreach (var argument in arguments)
{
typeMappedArguments.Add(
_sqlExpressionFactory.ApplyTypeMapping(
argument,
typeof(Geometry).IsAssignableFrom(argument.Type)
? _typeMappingSource.FindMapping(argument.Type, storeType)
: _typeMappingSource.FindMapping(argument.Type)));
}
var finalArguments = Simplify(new[] { typeMappedArguments[0] }, isGeography);
return(_sqlExpressionFactory.LessThanOrEqual(
_sqlExpressionFactory.Function(
instance,
"STDistance",
finalArguments,
nullable: true,
instancePropagatesNullability: true,
argumentsPropagateNullability: finalArguments.Select(a => true),
typeof(double)),
typeMappedArguments[1]));
}
}
return(null);
}
/// <inheritdoc />
public virtual SqlExpression Translate(
SqlExpression instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
if (SupportedMethodTranslations.TryGetValue(method, out var sqlFunctionName))
{
var typeMapping = arguments.Count == 1
? ExpressionExtensions.InferTypeMapping(arguments[0])
: ExpressionExtensions.InferTypeMapping(arguments[0], arguments[1]);
var newArguments = new SqlExpression[arguments.Count];
newArguments[0] = _sqlExpressionFactory.ApplyTypeMapping(arguments[0], typeMapping);
if (arguments.Count == 2)
{
newArguments[1] = _sqlExpressionFactory.ApplyTypeMapping(arguments[1], typeMapping);
}
// Note: GREATER/LEAST only return NULL if *all* arguments are null, but we currently can't
// convey this.
return(_sqlExpressionFactory.Function(
sqlFunctionName,
newArguments,
nullable: true,
argumentsPropagateNullability: TrueArrays[newArguments.Length],
method.ReturnType,
typeMapping));
}
// PostgreSQL sign() returns 1, 0, -1, but in the same type as the argument, so we need to convert
// the return type to int.
if (SignMethodInfos.Contains(method))
{
return
(_sqlExpressionFactory.Convert(
_sqlExpressionFactory.Function(
"sign",
arguments,
nullable: true,
argumentsPropagateNullability: TrueArrays[1],
method.ReturnType),
typeof(int),
_typeMappingSource.FindMapping(typeof(int))));
}
if (method == RoundDecimalTwoParams)
{
return(_sqlExpressionFactory.Function("round", new[]
{
_sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[0]),
_sqlExpressionFactory.ApplyDefaultTypeMapping(arguments[1])
},
nullable: true,
argumentsPropagateNullability: TrueArrays[2],
method.ReturnType,
_typeMappingSource.FindMapping(typeof(decimal))));
}
// PostgreSQL treats NaN values as equal, against IEEE754
if (method == DoubleIsNanMethodInfo)
{
return(_sqlExpressionFactory.Equal(arguments[0], _sqlExpressionFactory.Constant(double.NaN)));
}
if (method == FloatIsNanMethodInfo)
{
return(_sqlExpressionFactory.Equal(arguments[0], _sqlExpressionFactory.Constant(float.NaN)));
}
if (method == DoubleIsPositiveInfinityMethodInfo)
{
return(_sqlExpressionFactory.Equal(arguments[0], _sqlExpressionFactory.Constant(double.PositiveInfinity)));
}
if (method == FloatIsPositiveInfinityMethodInfo)
{
return(_sqlExpressionFactory.Equal(arguments[0], _sqlExpressionFactory.Constant(float.PositiveInfinity)));
}
if (method == DoubleIsNegativeInfinityMethodInfo)
{
return(_sqlExpressionFactory.Equal(arguments[0], _sqlExpressionFactory.Constant(double.NegativeInfinity)));
}
if (method == FloatIsNegativeInfinityMethodInfo)
{
return(_sqlExpressionFactory.Equal(arguments[0], _sqlExpressionFactory.Constant(float.NegativeInfinity)));
}
return(null);
}
public virtual SqlExpression?Translate(
SqlExpression?instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
Check.NotNull(logger, nameof(logger));
if (instance != null)
{
if (_indexOfMethodInfo.Equals(method))
{
var argument = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, argument) !;
argument = _sqlExpressionFactory.ApplyTypeMapping(argument, stringTypeMapping);
SqlExpression charIndexExpression;
var storeType = stringTypeMapping.StoreType;
if (string.Equals(storeType, "nvarchar(max)", StringComparison.OrdinalIgnoreCase) ||
string.Equals(storeType, "varchar(max)", StringComparison.OrdinalIgnoreCase))
{
charIndexExpression = _sqlExpressionFactory.Function(
"CHARINDEX",
new[] { argument, _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping) },
nullable: true,
argumentsPropagateNullability: new[] { true, true },
typeof(long));
charIndexExpression = _sqlExpressionFactory.Convert(charIndexExpression, typeof(int));
}
else
{
charIndexExpression = _sqlExpressionFactory.Function(
"CHARINDEX",
new[] { argument, _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping) },
nullable: true,
argumentsPropagateNullability: new[] { true, true },
method.ReturnType);
}
charIndexExpression = _sqlExpressionFactory.Subtract(charIndexExpression, _sqlExpressionFactory.Constant(1));
return(_sqlExpressionFactory.Case(
new[]
{
new CaseWhenClause(
_sqlExpressionFactory.Equal(
argument,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
_sqlExpressionFactory.Constant(0))
},
charIndexExpression));
}
if (_replaceMethodInfo.Equals(method))
{
var firstArgument = arguments[0];
var secondArgument = arguments[1];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, firstArgument, secondArgument);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
firstArgument = _sqlExpressionFactory.ApplyTypeMapping(firstArgument, stringTypeMapping);
secondArgument = _sqlExpressionFactory.ApplyTypeMapping(secondArgument, stringTypeMapping);
return(_sqlExpressionFactory.Function(
"REPLACE",
new[] { instance, firstArgument, secondArgument },
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType,
stringTypeMapping));
}
if (_toLowerMethodInfo.Equals(method) ||
_toUpperMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
_toLowerMethodInfo.Equals(method) ? "LOWER" : "UPPER",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
method.ReturnType,
instance.TypeMapping));
}
if (_substringMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[]
{
instance,
_sqlExpressionFactory.Add(
arguments[0],
_sqlExpressionFactory.Constant(1)),
arguments[1]
},
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType,
instance.TypeMapping));
}
if (_trimStartMethodInfoWithoutArgs?.Equals(method) == true ||
(_trimStartMethodInfoWithCharArrayArg.Equals(method)
// SqlServer LTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"LTRIM",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping));
}
if (_trimEndMethodInfoWithoutArgs?.Equals(method) == true ||
(_trimEndMethodInfoWithCharArrayArg.Equals(method)
// SqlServer RTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"RTRIM",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping));
}
if (_trimMethodInfoWithoutArgs?.Equals(method) == true ||
(_trimMethodInfoWithCharArrayArg.Equals(method)
// SqlServer LTRIM/RTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"LTRIM",
new[]
{
_sqlExpressionFactory.Function(
"RTRIM",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping)
},
nullable: true,
argumentsPropagateNullability: new[] { true },
instance.Type,
instance.TypeMapping));
}
if (_containsMethodInfo.Equals(method))
{
var pattern = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, pattern);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
pattern = _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping);
if (pattern is SqlConstantExpression constantPattern)
{
if (!(constantPattern.Value is string patternValue))
{
return(_sqlExpressionFactory.Like(
instance,
_sqlExpressionFactory.Constant(null, stringTypeMapping)));
}
if (patternValue.Length == 0)
{
return(_sqlExpressionFactory.Constant(true));
}
return(patternValue.Any(IsLikeWildChar)
? _sqlExpressionFactory.Like(
instance,
_sqlExpressionFactory.Constant($"%{EscapeLikePattern(patternValue)}%"),
_sqlExpressionFactory.Constant(LikeEscapeString))
: _sqlExpressionFactory.Like(instance, _sqlExpressionFactory.Constant($"%{patternValue}%")));
}
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.Like(
pattern,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
_sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"CHARINDEX",
new[] { pattern, instance },
nullable: true,
argumentsPropagateNullability: new[] { true, true },
typeof(int)),
_sqlExpressionFactory.Constant(0))));
}
if (_startsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], true));
}
if (_endsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], false));
}
}
if (_isNullOrEmptyMethodInfo.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Like(
argument,
_sqlExpressionFactory.Constant(string.Empty))));
}
if (_isNullOrWhiteSpaceMethodInfo.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Equal(
argument,
_sqlExpressionFactory.Constant(string.Empty, argument.TypeMapping))));
}
if (_firstOrDefaultMethodInfoWithoutArgs.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[] { argument, _sqlExpressionFactory.Constant(1), _sqlExpressionFactory.Constant(1) },
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType));
}
if (_lastOrDefaultMethodInfoWithoutArgs.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[]
{
argument,
_sqlExpressionFactory.Function(
"LEN",
new[] { argument },
nullable: true,
argumentsPropagateNullability: new[] { true },
typeof(int)),
_sqlExpressionFactory.Constant(1)
},
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType));
}
return(null);
}
public SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (method == IndexOfString || method == IndexOfChar)
{
var argument = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, argument);
return(_sqlExpressionFactory.Subtract(
_sqlExpressionFactory.Function(
"STRPOS",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(argument, stringTypeMapping)
},
method.ReturnType),
_sqlExpressionFactory.Constant(1)));
}
if (method == Replace)
{
var oldValue = arguments[0];
var newValue = arguments[1];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, oldValue, newValue);
return(_sqlExpressionFactory.Function(
"REPLACE",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(oldValue, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(newValue, stringTypeMapping)
},
method.ReturnType,
stringTypeMapping));
}
if (method == ToLower || method == ToUpper)
{
return(_sqlExpressionFactory.Function(
method == ToLower ? "LOWER" : "UPPER",
new[] { instance },
method.ReturnType,
instance.TypeMapping));
}
if (method == Substring || method == SubstringWithLength)
{
var args =
method == Substring
? new[] { instance, GenerateOneBasedIndexExpression(arguments[0]) }
: new[] { instance, GenerateOneBasedIndexExpression(arguments[0]), arguments[1] };
return(_sqlExpressionFactory.Function(
"SUBSTRING",
args,
method.ReturnType,
instance.TypeMapping));
}
if (method == IsNullOrWhiteSpace)
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Equal(
_sqlExpressionFactory.Function(
"BTRIM",
new[]
{
argument,
_whitespace
},
argument.Type,
argument.TypeMapping),
_sqlExpressionFactory.Constant(string.Empty, argument.TypeMapping))));
}
var isTrimStart = method == TrimStartWithNoParam || method == TrimStartWithChars || method == TrimStartWithSingleChar;
var isTrimEnd = method == TrimEndWithNoParam || method == TrimEndWithChars || method == TrimEndWithSingleChar;
var isTrimBoth = method == TrimBothWithNoParam || method == TrimBothWithChars || method == TrimBothWithSingleChar;
if (isTrimStart || isTrimEnd || isTrimBoth)
{
char[] trimChars = null;
if (method == TrimStartWithChars || method == TrimStartWithSingleChar ||
method == TrimEndWithChars || method == TrimEndWithSingleChar ||
method == TrimBothWithChars || method == TrimBothWithSingleChar)
{
var constantTrimChars = arguments[0] as SqlConstantExpression;
if (constantTrimChars == null)
{
return(null); // Don't translate if trim chars isn't a constant
}
trimChars = constantTrimChars.Value is char c
? new[] { c }
: (char[])constantTrimChars.Value;
}
return(_sqlExpressionFactory.Function(
isTrimStart ? "LTRIM" : isTrimEnd ? "RTRIM" : "BTRIM",
new[]
{
instance,
trimChars == null || trimChars.Length == 0
? _whitespace
: _sqlExpressionFactory.Constant(new string(trimChars))
},
instance.Type,
instance.TypeMapping));
}
if (method == Contains)
{
var pattern = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, pattern);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
pattern = _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping);
var strposCheck = _sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"STRPOS",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping)
},
typeof(int)),
_sqlExpressionFactory.Constant(0));
if (pattern is SqlConstantExpression constantPattern)
{
return((string)constantPattern.Value == string.Empty
? (SqlExpression)_sqlExpressionFactory.Constant(true)
: strposCheck);
}
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.Equal(
pattern,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
strposCheck));
}
if (method == PadLeft || method == PadLeftWithChar || method == PadRight || method == PadRightWithChar)
{
var args =
method == PadLeft || method == PadRight
? new[] { instance, arguments[0] }
: new[] { instance, arguments[0], arguments[1] };
return(_sqlExpressionFactory.Function(
method == PadLeft || method == PadLeftWithChar ? "lpad" : "rpad",
args,
instance.Type,
instance.TypeMapping));
}
if (method == StartsWith)
{
return(TranslateStartsEndsWith(instance, arguments[0], true));
}
if (method == EndsWith)
{
return(TranslateStartsEndsWith(instance, arguments[0], false));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (_indexOfMethodInfo.Equals(method))
{
var argument = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, argument);
argument = _sqlExpressionFactory.ApplyTypeMapping(argument, stringTypeMapping);
var charIndexExpression = _sqlExpressionFactory.Subtract(
_sqlExpressionFactory.Function(
"CHARINDEX",
new[] { argument, _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping) },
method.ReturnType),
_sqlExpressionFactory.Constant(1));
return(_sqlExpressionFactory.Case(
new[]
{
new CaseWhenClause(
_sqlExpressionFactory.Equal(
argument,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
_sqlExpressionFactory.Constant(0))
},
charIndexExpression));
}
if (_replaceMethodInfo.Equals(method))
{
var firstArgument = arguments[0];
var secondArgument = arguments[1];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, firstArgument, secondArgument);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
firstArgument = _sqlExpressionFactory.ApplyTypeMapping(firstArgument, stringTypeMapping);
secondArgument = _sqlExpressionFactory.ApplyTypeMapping(secondArgument, stringTypeMapping);
return(_sqlExpressionFactory.Function(
"REPLACE",
new[] { instance, firstArgument, secondArgument },
method.ReturnType,
stringTypeMapping));
}
if (_toLowerMethodInfo.Equals(method) ||
_toUpperMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
_toLowerMethodInfo.Equals(method) ? "LOWER" : "UPPER",
new[] { instance },
method.ReturnType,
instance.TypeMapping));
}
if (_substringMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[]
{
instance,
_sqlExpressionFactory.Add(
arguments[0],
_sqlExpressionFactory.Constant(1)),
arguments[1]
},
method.ReturnType,
instance.TypeMapping));
}
if (_isNullOrWhiteSpaceMethodInfo.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Equal(
_sqlExpressionFactory.Function(
"LTRIM",
new[]
{
_sqlExpressionFactory.Function(
"RTRIM",
new[] { argument },
argument.Type,
argument.TypeMapping)
},
argument.Type,
argument.TypeMapping),
_sqlExpressionFactory.Constant(string.Empty, argument.TypeMapping))));
}
if (_trimStartMethodInfoWithoutArgs?.Equals(method) == true ||
(_trimStartMethodInfoWithCharArrayArg.Equals(method)
// SqlServer LTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"LTRIM",
new[] { instance },
instance.Type,
instance.TypeMapping));
}
if (_trimEndMethodInfoWithoutArgs?.Equals(method) == true ||
(_trimEndMethodInfoWithCharArrayArg.Equals(method)
// SqlServer RTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"RTRIM",
new[] { instance },
instance.Type,
instance.TypeMapping));
}
if (_trimMethodInfoWithoutArgs?.Equals(method) == true ||
(_trimMethodInfoWithCharArrayArg.Equals(method)
// SqlServer LTRIM/RTRIM does not take arguments
&& ((arguments[0] as SqlConstantExpression)?.Value as Array)?.Length == 0))
{
return(_sqlExpressionFactory.Function(
"LTRIM",
new[]
{
_sqlExpressionFactory.Function(
"RTRIM",
new[] { instance },
instance.Type,
instance.TypeMapping)
},
instance.Type,
instance.TypeMapping));
}
if (_containsMethodInfo.Equals(method))
{
var pattern = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, pattern);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
pattern = _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping);
if (pattern is SqlConstantExpression constantPattern)
{
if ((string)constantPattern.Value == string.Empty)
{
return(_sqlExpressionFactory.Constant(true));
}
return(_sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"CHARINDEX",
new[] { pattern, instance },
typeof(int)),
_sqlExpressionFactory.Constant(0)));
}
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.Equal(
pattern,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
_sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"CHARINDEX",
new[] { pattern, instance },
typeof(int)),
_sqlExpressionFactory.Constant(0))));
}
if (_startsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], true));
}
if (_endsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], false));
}
return(null);
}
public SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments, IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
if (_methodInfoDateAddMapping != null && _methodInfoDateAddMapping.TryGetValue(method, out var dateAddPart))
{
return(arguments[0] is SqlConstantExpression sqlConstant &&
((sqlConstant.Value is double && ((double)sqlConstant.Value >= int.MaxValue || (double)sqlConstant.Value <= int.MinValue)) ||
(sqlConstant.Value is long && ((long)sqlConstant.Value >= int.MaxValue || (long)sqlConstant.Value <= int.MinValue)))
? null
: _sqlExpressionFactory.Function(
"DATEADD",
new[]
{
_sqlExpressionFactory.Fragment(dateAddPart),
_sqlExpressionFactory.Convert(arguments[0], typeof(int)),
instance
},
instance.Type,
instance.TypeMapping));
}
else if (_methodInfoDateAddExtensionMapping != null && _methodInfoDateAddExtensionMapping.TryGetValue(method, out var dateAddExtensionPart))
{
return(arguments[1] is SqlConstantExpression sqlConstant &&
((sqlConstant.Value is double && ((double)sqlConstant.Value >= int.MaxValue || (double)sqlConstant.Value <= int.MinValue)) ||
(sqlConstant.Value is long && ((long)sqlConstant.Value >= int.MaxValue || (long)sqlConstant.Value <= int.MinValue)))
? null
: _sqlExpressionFactory.Function(
"DATEADD",
new[]
{
_sqlExpressionFactory.Fragment(dateAddExtensionPart),
_sqlExpressionFactory.Convert(arguments[1], typeof(int)),
arguments[0]
},
arguments[0].Type,
arguments[0].TypeMapping));
}
else if (_methodInfoDatePartExtensionMapping != null && _methodInfoDatePartExtensionMapping.TryGetValue(method, out var datePart))
{
return(_sqlExpressionFactory.Function(
"DATEPART",
new[]
{
_sqlExpressionFactory.Fragment(datePart),
arguments[0]
},
method.ReturnType,
null));
}
else if (_methodInfoDateDiffMapping != null && _methodInfoDateDiffMapping.TryGetValue(method, out var dateDiffDatePart))
{
var startDate = arguments[1];
var endDate = arguments[2];
var typeMapping = ExpressionExtensions.InferTypeMapping(startDate, endDate);
startDate = _sqlExpressionFactory.ApplyTypeMapping(startDate, typeMapping);
endDate = _sqlExpressionFactory.ApplyTypeMapping(endDate, typeMapping);
return(_sqlExpressionFactory.Function(
"DATEDIFF",
new[] { _sqlExpressionFactory.Fragment(dateDiffDatePart), startDate, endDate },
method.ReturnType,
null));
}
else if (_methodInfoDateDiffBigMapping != null && _methodInfoDateDiffBigMapping.TryGetValue(method, out var dateDiffBigDatePart))
{
var startDate = arguments[1];
var endDate = arguments[2];
var typeMapping = ExpressionExtensions.InferTypeMapping(startDate, endDate);
startDate = _sqlExpressionFactory.ApplyTypeMapping(startDate, typeMapping);
endDate = _sqlExpressionFactory.ApplyTypeMapping(endDate, typeMapping);
return(_sqlExpressionFactory.Function(
"DATEDIFF_BIG",
new[] { _sqlExpressionFactory.Fragment(dateDiffBigDatePart), startDate, endDate },
method.ReturnType,
null));
}
return(null);
}
public virtual SqlExpression?Translate(
SqlExpression?instance,
MethodInfo method,
IReadOnlyList <SqlExpression> arguments,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(method, nameof(method));
Check.NotNull(arguments, nameof(arguments));
Check.NotNull(logger, nameof(logger));
if (instance != null)
{
if (_indexOfMethodInfo.Equals(method))
{
var argument = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, argument);
return(_sqlExpressionFactory.Subtract(
_sqlExpressionFactory.Function(
"instr",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(argument, stringTypeMapping)
},
nullable: true,
argumentsPropagateNullability: new[] { true, true },
method.ReturnType),
_sqlExpressionFactory.Constant(1)));
}
if (_replaceMethodInfo.Equals(method))
{
var firstArgument = arguments[0];
var secondArgument = arguments[1];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, firstArgument, secondArgument);
return(_sqlExpressionFactory.Function(
"replace",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(firstArgument, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(secondArgument, stringTypeMapping)
},
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType,
stringTypeMapping));
}
if (_toLowerMethodInfo.Equals(method) ||
_toUpperMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
_toLowerMethodInfo.Equals(method) ? "lower" : "upper",
new[] { instance },
nullable: true,
argumentsPropagateNullability: new[] { true },
method.ReturnType,
instance.TypeMapping));
}
if (_substringMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
"substr",
new[] { instance, _sqlExpressionFactory.Add(arguments[0], _sqlExpressionFactory.Constant(1)), arguments[1] },
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType,
instance.TypeMapping));
}
if (_trimStartMethodInfoWithoutArgs?.Equals(method) == true ||
_trimStartMethodInfoWithCharArg?.Equals(method) == true ||
_trimStartMethodInfoWithCharArrayArg.Equals(method))
{
return(ProcessTrimMethod(instance, arguments, "ltrim"));
}
if (_trimEndMethodInfoWithoutArgs?.Equals(method) == true ||
_trimEndMethodInfoWithCharArg?.Equals(method) == true ||
_trimEndMethodInfoWithCharArrayArg.Equals(method))
{
return(ProcessTrimMethod(instance, arguments, "rtrim"));
}
if (_trimMethodInfoWithoutArgs?.Equals(method) == true ||
_trimMethodInfoWithCharArg?.Equals(method) == true ||
_trimMethodInfoWithCharArrayArg.Equals(method))
{
return(ProcessTrimMethod(instance, arguments, "trim"));
}
if (_containsMethodInfo.Equals(method))
{
var pattern = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, pattern);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
pattern = _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping);
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.Equal(
pattern,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
_sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"instr",
new[] { instance, pattern },
nullable: true,
argumentsPropagateNullability: new[] { true, true },
typeof(int)),
_sqlExpressionFactory.Constant(0))));
}
if (_startsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], true));
}
if (_endsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], false));
}
}
if (_isNullOrWhiteSpaceMethodInfo.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Equal(
_sqlExpressionFactory.Function(
"trim",
new[] { argument },
nullable: true,
argumentsPropagateNullability: new[] { true },
argument.Type,
argument.TypeMapping),
_sqlExpressionFactory.Constant(string.Empty))));
}
if (_firstOrDefaultMethodInfoWithoutArgs.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"substr",
new[] { argument, _sqlExpressionFactory.Constant(1), _sqlExpressionFactory.Constant(1) },
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType));
}
if (_lastOrDefaultMethodInfoWithoutArgs.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.Function(
"substr",
new[]
{
argument,
_sqlExpressionFactory.Function(
"length",
new[] { argument },
nullable: true,
argumentsPropagateNullability: new[] { true },
typeof(int)),
_sqlExpressionFactory.Constant(1)
},
nullable: true,
argumentsPropagateNullability: new[] { true, true, true },
method.ReturnType));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (_indexOfMethodInfo.Equals(method))
{
var argument = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, argument);
return(_sqlExpressionFactory.Subtract(
_sqlExpressionFactory.Function(
"instr",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(argument, stringTypeMapping)
}, true, null,
method.ReturnType),
_sqlExpressionFactory.Constant(1)));
}
if (_replaceMethodInfo.Equals(method))
{
var firstArgument = arguments[0];
var secondArgument = arguments[1];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, firstArgument, secondArgument);
return(_sqlExpressionFactory.Function(
"replace",
new[]
{
_sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(firstArgument, stringTypeMapping),
_sqlExpressionFactory.ApplyTypeMapping(secondArgument, stringTypeMapping)
}, true, null,
method.ReturnType,
stringTypeMapping));
}
if (_toLowerMethodInfo.Equals(method) ||
_toUpperMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
_toLowerMethodInfo.Equals(method) ? "lower" : "upper",
new[] { instance }, true, null,
method.ReturnType,
instance.TypeMapping));
}
if (_substringMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
"substr",
new[] { instance, _sqlExpressionFactory.Add(arguments[0], _sqlExpressionFactory.Constant(1)), arguments[1] }, true, null,
method.ReturnType,
instance.TypeMapping));
}
if (_isNullOrWhiteSpaceMethodInfo.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Equal(
_sqlExpressionFactory.Function(
"trim", new[] { argument }, true, null, argument.Type, argument.TypeMapping),
_sqlExpressionFactory.Constant(string.Empty))));
}
if (_trimStartMethodInfoWithoutArgs?.Equals(method) == true ||
_trimStartMethodInfoWithCharArg?.Equals(method) == true ||
_trimStartMethodInfoWithCharArrayArg.Equals(method))
{
return(ProcessTrimMethod(instance, arguments, "ltrim"));
}
if (_trimEndMethodInfoWithoutArgs?.Equals(method) == true ||
_trimEndMethodInfoWithCharArg?.Equals(method) == true ||
_trimEndMethodInfoWithCharArrayArg.Equals(method))
{
return(ProcessTrimMethod(instance, arguments, "rtrim"));
}
if (_trimMethodInfoWithoutArgs?.Equals(method) == true ||
_trimMethodInfoWithCharArg?.Equals(method) == true ||
_trimMethodInfoWithCharArrayArg.Equals(method))
{
return(ProcessTrimMethod(instance, arguments, "trim"));
}
if (_containsMethodInfo.Equals(method))
{
var pattern = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, pattern);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
pattern = _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping);
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.Equal(
pattern,
_sqlExpressionFactory.Constant(string.Empty, stringTypeMapping)),
_sqlExpressionFactory.GreaterThan(
_sqlExpressionFactory.Function(
"instr",
new[] { instance, pattern }, true, null,
typeof(int)),
_sqlExpressionFactory.Constant(0))));
}
if (_startsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], true));
}
if (_endsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], false));
}
return(null);
}
public virtual SqlExpression Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (typeof(Geometry).IsAssignableFrom(method.DeclaringType))
{
var geometryExpressions = new[] { instance }.Concat(
arguments.Where(e => typeof(Geometry).IsAssignableFrom(e.Type)));
var typeMapping = ExpressionExtensions.InferTypeMapping(geometryExpressions.ToArray());
Debug.Assert(typeMapping != null, "At least one argument must have typeMapping.");
var storeType = typeMapping.StoreType;
var isGeography = string.Equals(storeType, "geography", StringComparison.OrdinalIgnoreCase);
if (_methodToFunctionName.TryGetValue(method, out var functionName) ||
(!isGeography && _geometryMethodToFunctionName.TryGetValue(method, out functionName)))
{
instance = _sqlExpressionFactory.ApplyTypeMapping(
instance, _typeMappingSource.FindMapping(instance.Type, storeType));
var typeMappedArguments = new List <SqlExpression>();
foreach (var argument in arguments)
{
typeMappedArguments.Add(
_sqlExpressionFactory.ApplyTypeMapping(
argument,
typeof(Geometry).IsAssignableFrom(argument.Type)
? _typeMappingSource.FindMapping(argument.Type, storeType)
: _typeMappingSource.FindMapping(argument.Type)));
}
var resultTypeMapping = typeof(Geometry).IsAssignableFrom(method.ReturnType)
? _typeMappingSource.FindMapping(method.ReturnType, storeType)
: _typeMappingSource.FindMapping(method.ReturnType);
return(_sqlExpressionFactory.Function(
instance,
functionName,
Simplify(typeMappedArguments, isGeography),
method.ReturnType,
resultTypeMapping));
}
if (Equals(method, _getGeometryN))
{
return(_sqlExpressionFactory.Function(
instance,
"STGeometryN",
new[] {
_sqlExpressionFactory.Add(
arguments[0],
_sqlExpressionFactory.Constant(1))
},
method.ReturnType,
_typeMappingSource.FindMapping(method.ReturnType, storeType)));
}
if (Equals(method, _isWithinDistance))
{
instance = _sqlExpressionFactory.ApplyTypeMapping(
instance, _typeMappingSource.FindMapping(instance.Type, storeType));
var typeMappedArguments = new List <SqlExpression>();
foreach (var argument in arguments)
{
typeMappedArguments.Add(
_sqlExpressionFactory.ApplyTypeMapping(
argument,
typeof(Geometry).IsAssignableFrom(argument.Type)
? _typeMappingSource.FindMapping(argument.Type, storeType)
: _typeMappingSource.FindMapping(argument.Type)));
}
return(_sqlExpressionFactory.LessThanOrEqual(
_sqlExpressionFactory.Function(
instance,
"STDistance",
Simplify(new[] { typeMappedArguments[0] }, isGeography),
typeof(double)),
typeMappedArguments[1]));
}
}
return(null);
}
public SqlExpression?Translate(SqlExpression instance, MethodInfo method, IReadOnlyList <SqlExpression> arguments)
{
if (_toLowerMethodInfo.Equals(method) ||
_toUpperMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
_toLowerMethodInfo.Equals(method) ? "LOWER" : "UPPER",
new[] { instance },
method.ReturnType,
instance.TypeMapping));
}
if (_substringMethodInfo.Equals(method))
{
return(_sqlExpressionFactory.Function(
"SUBSTRING",
new[] { instance, _sqlExpressionFactory.Add(arguments[0], _sqlExpressionFactory.Constant(1)), arguments[1] },
method.ReturnType,
instance.TypeMapping));
}
if (_isNullOrWhiteSpaceMethodInfo.Equals(method))
{
var argument = arguments[0];
return(_sqlExpressionFactory.OrElse(
_sqlExpressionFactory.IsNull(argument),
_sqlExpressionFactory.Equal(
_sqlExpressionFactory.Function(
"TRIM", new[] { argument }, argument.Type, argument.TypeMapping),
_sqlExpressionFactory.Constant(string.Empty))));
}
if (_containsMethodInfo.Equals(method))
{
var pattern = arguments[0];
var stringTypeMapping = ExpressionExtensions.InferTypeMapping(instance, pattern);
instance = _sqlExpressionFactory.ApplyTypeMapping(instance, stringTypeMapping);
pattern = _sqlExpressionFactory.ApplyTypeMapping(pattern, stringTypeMapping);
if (pattern is SqlConstantExpression constantExpression)
{
if (constantExpression.Value is string constantString)
{
return(constantString.Any(c => IsLikeWildChar(c))
? _sqlExpressionFactory.Like(
instance,
_sqlExpressionFactory.Constant('%' + EscapeLikePattern(constantString) + '%'))
: _sqlExpressionFactory.Like(
instance,
_sqlExpressionFactory.Constant('%' + constantString + '%')));
}
}
}
if (_startsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], true));
}
if (_endsWithMethodInfo.Equals(method))
{
return(TranslateStartsEndsWith(instance, arguments[0], false));
}
return(null);
}
