forked from npgsql/efcore.pg
-
Notifications
You must be signed in to change notification settings - Fork 0
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Fixes npgsql#212
- Loading branch information
Showing
9 changed files
with
794 additions
and
3 deletions.
There are no files selected for viewing
248 changes: 248 additions & 0 deletions
248
src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlHstoreTranslator.cs
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,248 @@ | ||
using System.Collections.Immutable; | ||
using Npgsql.EntityFrameworkCore.PostgreSQL.Query.Expressions; | ||
using Npgsql.EntityFrameworkCore.PostgreSQL.Query.Expressions.Internal; | ||
using static Npgsql.EntityFrameworkCore.PostgreSQL.Utilities.Statics; | ||
|
||
namespace Npgsql.EntityFrameworkCore.PostgreSQL.Query.ExpressionTranslators.Internal; | ||
|
||
/// <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 class NpgsqlHstoreTranslator : IMethodCallTranslator, IMemberTranslator | ||
{ | ||
private static readonly Type DictionaryType = typeof(Dictionary<string, string>); | ||
private static readonly Type ImmutableDictionaryType = typeof(ImmutableDictionary<string, string>); | ||
|
||
private static readonly MethodInfo Dictionary_ContainsKey = | ||
DictionaryType.GetMethod(nameof(Dictionary<string, string>.ContainsKey))!; | ||
|
||
private static readonly MethodInfo ImmutableDictionary_ContainsKey = | ||
ImmutableDictionaryType.GetMethod(nameof(ImmutableDictionary<string, string>.ContainsKey))!; | ||
|
||
private static readonly MethodInfo Dictionary_ContainsValue = | ||
DictionaryType.GetMethod(nameof(Dictionary<string, string>.ContainsValue))!; | ||
|
||
private static readonly MethodInfo ImmutableDictionary_ContainsValue = | ||
ImmutableDictionaryType.GetMethod(nameof(ImmutableDictionary<string, string>.ContainsValue))!; | ||
|
||
private static readonly MethodInfo Dictionary_Item_Getter = | ||
DictionaryType.FindIndexerProperty()!.GetMethod!; | ||
|
||
private static readonly MethodInfo ImmutableDictionary_Item_Getter = | ||
ImmutableDictionaryType.FindIndexerProperty()!.GetMethod!; | ||
|
||
private static readonly MethodInfo Enumerable_Any = | ||
typeof(Enumerable).GetMethod( | ||
nameof(Enumerable.Any), BindingFlags.Public | BindingFlags.Static, | ||
[typeof(IEnumerable<>).MakeGenericType(Type.MakeGenericMethodParameter(0))])! | ||
.MakeGenericMethod(typeof(KeyValuePair<string, string>)); | ||
|
||
private static readonly MethodInfo Enumerable_ToList = | ||
typeof(Enumerable).GetMethod( | ||
nameof(Enumerable.ToList), BindingFlags.Public | BindingFlags.Static, | ||
[typeof(IEnumerable<>).MakeGenericType(Type.MakeGenericMethodParameter(0))])! | ||
.MakeGenericMethod(typeof(string)); | ||
|
||
private static readonly MethodInfo Enumerable_ToDictionary = | ||
typeof(Enumerable).GetMethod( | ||
nameof(Enumerable.ToDictionary), BindingFlags.Public | BindingFlags.Static, | ||
[ | ||
typeof(IEnumerable<>).MakeGenericType( | ||
typeof(KeyValuePair<,>).MakeGenericType(Type.MakeGenericMethodParameter(0), Type.MakeGenericMethodParameter(1))) | ||
])!.MakeGenericMethod(typeof(string), typeof(string)); | ||
|
||
private static readonly MethodInfo ImmutableDictionary_ToImmutableDictionary = | ||
typeof(ImmutableDictionary).GetMethod( | ||
nameof(ImmutableDictionary.ToImmutableDictionary), BindingFlags.Public | BindingFlags.Static, | ||
[ | ||
typeof(IEnumerable<>).MakeGenericType( | ||
typeof(KeyValuePair<,>).MakeGenericType(Type.MakeGenericMethodParameter(0), Type.MakeGenericMethodParameter(1))) | ||
])!.MakeGenericMethod(typeof(string), typeof(string)); | ||
|
||
private static readonly MethodInfo Enumerable_Concat = typeof(Enumerable).GetMethod( | ||
nameof(Enumerable.Concat), BindingFlags.Public | BindingFlags.Static, | ||
[ | ||
typeof(IEnumerable<>).MakeGenericType(Type.MakeGenericMethodParameter(0)), | ||
typeof(IEnumerable<>).MakeGenericType(Type.MakeGenericMethodParameter(0)) | ||
])!.MakeGenericMethod(typeof(KeyValuePair<string, string>)); | ||
|
||
private static readonly PropertyInfo Dictionary_Count = DictionaryType.GetProperty(nameof(Dictionary<string, string>.Count))!; | ||
|
||
private static readonly PropertyInfo ImmutableDictionary_Count = | ||
ImmutableDictionaryType.GetProperty(nameof(ImmutableDictionary<string, string>.Count))!; | ||
|
||
private static readonly PropertyInfo ImmutableDictionary_IsEmpty = | ||
ImmutableDictionaryType.GetProperty(nameof(ImmutableDictionary<string, string>.IsEmpty))!; | ||
|
||
private static readonly PropertyInfo Dictionary_Keys = DictionaryType.GetProperty(nameof(Dictionary<string, string>.Keys))!; | ||
|
||
private static readonly PropertyInfo ImmutableDictionary_Keys = | ||
ImmutableDictionaryType.GetProperty(nameof(ImmutableDictionary<string, string>.Keys))!; | ||
|
||
private static readonly PropertyInfo Dictionary_Values = DictionaryType.GetProperty(nameof(Dictionary<string, string>.Values))!; | ||
|
||
private static readonly PropertyInfo ImmutableDictionary_Values = | ||
ImmutableDictionaryType.GetProperty(nameof(ImmutableDictionary<string, string>.Values))!; | ||
|
||
private readonly RelationalTypeMapping _stringListTypeMapping; | ||
private readonly RelationalTypeMapping _stringTypeMapping; | ||
private readonly RelationalTypeMapping _dictionaryMapping; | ||
private readonly RelationalTypeMapping _immutableDictionaryMapping; | ||
private readonly NpgsqlSqlExpressionFactory _sqlExpressionFactory; | ||
/// <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 NpgsqlHstoreTranslator(IRelationalTypeMappingSource typeMappingSource, NpgsqlSqlExpressionFactory sqlExpressionFactory) | ||
{ | ||
_sqlExpressionFactory = sqlExpressionFactory; | ||
_stringListTypeMapping = typeMappingSource.FindMapping(typeof(List<string>))!; | ||
_stringTypeMapping = typeMappingSource.FindMapping(typeof(string))!; | ||
_dictionaryMapping = typeMappingSource.FindMapping(DictionaryType)!; | ||
_immutableDictionaryMapping = typeMappingSource.FindMapping(ImmutableDictionaryType)!; | ||
} | ||
|
||
/// <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 SqlExpression? Translate( | ||
SqlExpression? instance, | ||
MethodInfo method, | ||
IReadOnlyList<SqlExpression> arguments, | ||
IDiagnosticsLogger<DbLoggerCategory.Query> logger) | ||
{ | ||
if (instance is null) | ||
{ | ||
if (arguments.Count is 2) | ||
{ | ||
if (method == Enumerable_Concat | ||
&& arguments[0].TypeMapping?.StoreType == "hstore" | ||
&& arguments[1].TypeMapping?.StoreType == "hstore") | ||
{ | ||
return _sqlExpressionFactory.MakePostgresBinary( | ||
PgExpressionType.HStoreConcat, arguments[0], arguments[1], arguments[1].TypeMapping); | ||
} | ||
|
||
return null; | ||
} | ||
|
||
if (arguments.Count is not 1) | ||
{ | ||
return null; | ||
} | ||
|
||
if (arguments[0].TypeMapping?.StoreType == "hstore") | ||
{ | ||
if (method == Enumerable_Any) | ||
{ | ||
return _sqlExpressionFactory.NotEqual(Count(arguments[0]), _sqlExpressionFactory.Constant(0)); | ||
} | ||
|
||
if (method == Enumerable_ToDictionary) | ||
{ | ||
return arguments[0].Type == ImmutableDictionaryType | ||
? _sqlExpressionFactory.Convert(arguments[0], DictionaryType, _dictionaryMapping) | ||
: arguments[0]; | ||
} | ||
|
||
if (method == ImmutableDictionary_ToImmutableDictionary) | ||
{ | ||
return arguments[0].Type == DictionaryType | ||
? _sqlExpressionFactory.Convert(arguments[0], ImmutableDictionaryType, _immutableDictionaryMapping) | ||
: arguments[0]; | ||
} | ||
|
||
return null; | ||
} | ||
|
||
if (method == Enumerable_ToList && arguments[0] is SqlFunctionExpression { Arguments: [{ TypeMapping.StoreType: "hstore" }] }) | ||
{ | ||
return arguments[0]; | ||
} | ||
|
||
return null; | ||
} | ||
|
||
if (instance.TypeMapping?.StoreType != "hstore") | ||
{ | ||
return null; | ||
} | ||
|
||
if (method == Dictionary_ContainsKey || method == ImmutableDictionary_ContainsKey) | ||
{ | ||
return _sqlExpressionFactory.MakePostgresBinary(PgExpressionType.HStoreContainsKey, instance, arguments[0]); | ||
} | ||
|
||
if (method == Dictionary_ContainsValue || method == ImmutableDictionary_ContainsValue) | ||
{ | ||
return _sqlExpressionFactory.Any(arguments[0], Values(instance), PgAnyOperatorType.Equal); | ||
} | ||
|
||
if (method == Dictionary_Item_Getter || method == ImmutableDictionary_Item_Getter) | ||
{ | ||
return _sqlExpressionFactory.MakePostgresBinary(PgExpressionType.HStoreValueForKey, instance, arguments[0], _stringTypeMapping); | ||
} | ||
|
||
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 SqlExpression? Translate( | ||
SqlExpression? instance, | ||
MemberInfo member, | ||
Type returnType, | ||
IDiagnosticsLogger<DbLoggerCategory.Query> logger) | ||
{ | ||
|
||
if (instance?.TypeMapping?.StoreType != "hstore") | ||
{ | ||
return null; | ||
} | ||
|
||
if (member == Dictionary_Count || member == ImmutableDictionary_Count) | ||
{ | ||
return Count(instance, true); | ||
} | ||
|
||
if (member == Dictionary_Keys || member == ImmutableDictionary_Keys) | ||
{ | ||
return Keys(instance); | ||
} | ||
|
||
if (member == Dictionary_Values || member == ImmutableDictionary_Values) | ||
{ | ||
return Values(instance); | ||
} | ||
|
||
if (member == ImmutableDictionary_IsEmpty) | ||
{ | ||
return _sqlExpressionFactory.Equal(Count(instance), _sqlExpressionFactory.Constant(0)); | ||
} | ||
|
||
return null; | ||
} | ||
|
||
private SqlExpression Keys(SqlExpression instance) | ||
=> _sqlExpressionFactory.Function( | ||
"akeys", [instance], true, TrueArrays[1], typeof(List<string>), _stringListTypeMapping); | ||
|
||
private SqlExpression Values(SqlExpression instance) | ||
=> _sqlExpressionFactory.Function( | ||
"avals", [instance], true, TrueArrays[1], typeof(List<string>), _stringListTypeMapping); | ||
|
||
private SqlExpression Count(SqlExpression instance, bool nullable = false) | ||
=> _sqlExpressionFactory.Function("cardinality", [Keys(instance)], nullable, TrueArrays[1], typeof(int)); | ||
} |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.