forked from npgsql/npgsql
-
Notifications
You must be signed in to change notification settings - Fork 3
Expand file tree
/
Copy pathGlobalTypeMapper.cs
More file actions
298 lines (265 loc) · 10.8 KB
/
GlobalTypeMapper.cs
File metadata and controls
298 lines (265 loc) · 10.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading;
using Npgsql.Internal;
using Npgsql.Internal.Postgres;
namespace Npgsql.TypeMapping;
/// <inheritdoc />
sealed class GlobalTypeMapper : INpgsqlTypeMapper
{
readonly UserTypeMapper _userTypeMapper = new();
readonly List<IPgTypeInfoResolver> _pluginResolvers = new();
readonly ReaderWriterLockSlim _lock = new();
IPgTypeInfoResolver[] _typeMappingResolvers = Array.Empty<IPgTypeInfoResolver>();
internal List<HackyEnumTypeMapping> HackyEnumTypeMappings { get; } = new();
internal IEnumerable<IPgTypeInfoResolver> GetPluginResolvers()
{
var resolvers = new List<IPgTypeInfoResolver>();
_lock.EnterReadLock();
try
{
resolvers.AddRange(_pluginResolvers);
}
finally
{
_lock.ExitReadLock();
}
return resolvers;
}
internal IPgTypeInfoResolver? GetUserMappingsResolver()
{
_lock.EnterReadLock();
try
{
return _userTypeMapper.Items.Count > 0 ? _userTypeMapper.Build() : null;
}
finally
{
_lock.ExitReadLock();
}
}
internal void AddGlobalTypeMappingResolvers(IPgTypeInfoResolver[] resolvers, bool overwrite = false)
{
// Good enough logic to prevent SlimBuilder overriding the normal Builder.
if (overwrite || resolvers.Length > _typeMappingResolvers.Length)
{
_typeMappingResolvers = resolvers;
ResetTypeMappingCache();
}
}
void ResetTypeMappingCache() => _typeMappingOptions = null;
PgSerializerOptions? _typeMappingOptions;
PgSerializerOptions TypeMappingOptions
{
get
{
if (_typeMappingOptions is not null)
return _typeMappingOptions;
_lock.EnterReadLock();
try
{
var resolvers = new List<IPgTypeInfoResolver>();
resolvers.Add(_userTypeMapper.Build());
resolvers.AddRange(_pluginResolvers);
resolvers.AddRange(_typeMappingResolvers);
return _typeMappingOptions = new(PostgresMinimalDatabaseInfo.DefaultTypeCatalog)
{
// This means we don't ever have a missing oid for a datatypename as our canonical format is datatypenames.
PortableTypeIds = true,
// Don't throw if our catalog doesn't know the datatypename.
IntrospectionMode = true,
TypeInfoResolver = new TypeInfoResolverChain(resolvers)
};
}
finally
{
_lock.ExitReadLock();
}
}
}
internal DataTypeName? FindDataTypeName(Type type, object value)
{
DataTypeName? dataTypeName;
try
{
var typeInfo = TypeMappingOptions.GetTypeInfo(type);
if (typeInfo is PgResolverTypeInfo info)
dataTypeName = info.GetObjectResolution(value).PgTypeId.DataTypeName;
else
dataTypeName = typeInfo?.GetResolution().PgTypeId.DataTypeName;
}
catch
{
dataTypeName = null;
}
return dataTypeName;
}
internal static GlobalTypeMapper Instance { get; }
static GlobalTypeMapper()
=> Instance = new GlobalTypeMapper();
/// <summary>
/// Adds a type info resolver which can add or modify support for PostgreSQL types.
/// Typically used by plugins.
/// </summary>
/// <param name="resolver">The type resolver to be added.</param>
public void AddTypeInfoResolver(IPgTypeInfoResolver resolver)
{
_lock.EnterWriteLock();
try
{
var type = resolver.GetType();
// Since EFCore.PG plugins (and possibly other users) repeatedly call NpgsqlConnection.GlobalTypeMapper.UseNodaTime,
// we replace an existing resolver of the same CLR type.
if (_pluginResolvers.Count > 0 && _pluginResolvers[0].GetType() == type)
_pluginResolvers[0] = resolver;
for (var i = 0; i < _pluginResolvers.Count; i++)
{
if (_pluginResolvers[i].GetType() == type)
{
_pluginResolvers.RemoveAt(i);
break;
}
}
_pluginResolvers.Insert(0, resolver);
ResetTypeMappingCache();
}
finally
{
_lock.ExitWriteLock();
}
}
/// <inheritdoc />
public void Reset()
{
_lock.EnterWriteLock();
try
{
_pluginResolvers.Clear();
_userTypeMapper.Items.Clear();
HackyEnumTypeMappings.Clear();
}
finally
{
_lock.ExitWriteLock();
}
}
/// <inheritdoc />
public INpgsqlNameTranslator DefaultNameTranslator
{
get => _userTypeMapper.DefaultNameTranslator;
set => _userTypeMapper.DefaultNameTranslator = value;
}
/// <inheritdoc />
public INpgsqlTypeMapper MapEnum<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] TEnum>(string? pgName = null, INpgsqlNameTranslator? nameTranslator = null) where TEnum : struct, Enum
{
_lock.EnterWriteLock();
try
{
_userTypeMapper.MapEnum<TEnum>(pgName, nameTranslator);
// Temporary hack for EFCore.PG enum mapping compat
if (_userTypeMapper.Items.FirstOrDefault(i => i.ClrType == typeof(TEnum)) is UserTypeMapping userTypeMapping)
HackyEnumTypeMappings.Add(new(typeof(TEnum), userTypeMapping.PgTypeName, nameTranslator ?? DefaultNameTranslator));
ResetTypeMappingCache();
return this;
}
finally
{
_lock.ExitWriteLock();
}
}
/// <inheritdoc />
public bool UnmapEnum<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] TEnum>(string? pgName = null, INpgsqlNameTranslator? nameTranslator = null) where TEnum : struct, Enum
{
_lock.EnterWriteLock();
try
{
var removed = _userTypeMapper.UnmapEnum<TEnum>(pgName, nameTranslator);
// Temporary hack for EFCore.PG enum mapping compat
if (removed && ((List<UserTypeMapping>)_userTypeMapper.Items).FindIndex(m => m.ClrType == typeof(TEnum)) is > -1 and var index)
HackyEnumTypeMappings.RemoveAt(index);
ResetTypeMappingCache();
return removed;
}
finally
{
_lock.ExitWriteLock();
}
}
/// <inheritdoc />
[RequiresDynamicCode("Calling MapEnum with a Type can require creating new generic types or methods. This may not work when AOT compiling.")]
public INpgsqlTypeMapper MapEnum([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
Type clrType, string? pgName = null, INpgsqlNameTranslator? nameTranslator = null)
{
_lock.EnterWriteLock();
try
{
_userTypeMapper.MapEnum(clrType, pgName, nameTranslator);
ResetTypeMappingCache();
return this;
}
finally
{
_lock.ExitWriteLock();
}
}
/// <inheritdoc />
public bool UnmapEnum([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)]
Type clrType, string? pgName = null, INpgsqlNameTranslator? nameTranslator = null)
{
_lock.EnterWriteLock();
try
{
var result = _userTypeMapper.UnmapEnum(clrType, pgName, nameTranslator);
ResetTypeMappingCache();
return result;
}
finally
{
_lock.ExitWriteLock();
}
}
/// <inheritdoc />
[RequiresDynamicCode("Mapping composite types involves serializing arbitrary types, requiring require creating new generic types or methods. This is currently unsupported with NativeAOT, vote on issue #5303 if this is important to you.")]
public INpgsqlTypeMapper MapComposite<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] T>(string? pgName = null, INpgsqlNameTranslator? nameTranslator = null)
=> MapComposite(typeof(T), pgName, nameTranslator);
/// <inheritdoc />
[RequiresDynamicCode("Mapping composite types involves serializing arbitrary types, requiring require creating new generic types or methods. This is currently unsupported with NativeAOT, vote on issue #5303 if this is important to you.")]
public bool UnmapComposite<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] T>(string? pgName = null, INpgsqlNameTranslator? nameTranslator = null)
=> UnmapComposite(typeof(T), pgName, nameTranslator);
/// <inheritdoc />
[RequiresDynamicCode("Mapping composite types involves serializing arbitrary types, requiring require creating new generic types or methods. This is currently unsupported with NativeAOT, vote on issue #5303 if this is important to you.")]
public INpgsqlTypeMapper MapComposite([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)]
Type clrType, string? pgName = null, INpgsqlNameTranslator? nameTranslator = null)
{
_lock.EnterWriteLock();
try
{
_userTypeMapper.MapComposite(clrType, pgName, nameTranslator);
ResetTypeMappingCache();
return this;
}
finally
{
_lock.ExitWriteLock();
}
}
/// <inheritdoc />
[RequiresDynamicCode("Mapping composite types involves serializing arbitrary types, requiring require creating new generic types or methods. This is currently unsupported with NativeAOT, vote on issue #5303 if this is important to you.")]
public bool UnmapComposite([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)]
Type clrType, string? pgName = null, INpgsqlNameTranslator? nameTranslator = null)
{
_lock.EnterWriteLock();
try
{
var result = _userTypeMapper.UnmapComposite(clrType, pgName, nameTranslator);
ResetTypeMappingCache();
return result;
}
finally
{
_lock.ExitWriteLock();
}
}
}