internal partial class TypeHandlerRegistry

{

#region Members

internal NpgsqlConnector Connector { get; private set; }

internal TypeHandler UnrecognizedTypeHandler { get; private set; }

internal Dictionary<uint, TypeHandler> ByOID { get; private set; }

readonly Dictionary<DbType, TypeHandler> _byDbType;

readonly Dictionary<NpgsqlDbType, TypeHandler> _byNpgsqlDbType;

/// <summary>

/// Maps CLR types to their type handlers.

/// </summary>

readonly Dictionary<Type, TypeHandler> _byType;

/// <summary>

/// Maps CLR types to their array handlers.

/// </summary>

Dictionary<Type, TypeHandler> _arrayHandlerByType;

BackendTypes _backendTypes;

/// <summary>

/// A counter that is updated when this registry activates its global mappings.

/// Tracks <see cref="_globalMappingChangeCounter"/>, allows us to know when a pooled

/// connection's mappings are no longer up to date because a global mapping change has

/// occurred.

/// </summary>

int _globalMappingActivationCounter = -1;

/// <summary>

/// A counter that is incremented whenever a global mapping change occurs (e.g.

/// <see cref="MapEnumGlobally{T}"/>, <see cref="UnmapCompositeGlobally{T}"/>.

/// <seealso cref="_globalMappingActivationCounter"/>

/// </summary>

static int _globalMappingChangeCounter;

internal static readonly Dictionary<string, TypeAndMapping> HandlerTypes;

static readonly Dictionary<NpgsqlDbType, TypeAndMapping> HandlerTypesByNpsgqlDbType;

static readonly Dictionary<NpgsqlDbType, DbType> NpgsqlDbTypeToDbType;

static readonly Dictionary<DbType, NpgsqlDbType> DbTypeToNpgsqlDbType;

static readonly Dictionary<Type, NpgsqlDbType> TypeToNpgsqlDbType;

static readonly Dictionary<Type, DbType> TypeToDbType;

/// <summary>

/// Caches, for each connection string, the results of the backend type query in the form of a list of type

/// info structs keyed by the PG name.

/// Repeated connections to the same connection string reuse the query results and avoid an additional

/// roundtrip at open-time.

/// </summary>

static readonly ConcurrentDictionary<string, BackendTypes> BackendTypeCache = new ConcurrentDictionary<string, BackendTypes>();

static readonly ConcurrentDictionary<string, IEnumHandlerFactory> _globalEnumMappings;

static readonly ConcurrentDictionary<string, ICompositeHandlerFactory> _globalCompositeMappings;

internal static IDictionary<string, IEnumHandlerFactory> GlobalEnumMappings => _globalEnumMappings;

internal static IDictionary<string, ICompositeHandlerFactory> GlobalCompositeMappings => _globalCompositeMappings;

static readonly INpgsqlNameTranslator DefaultNameTranslator = new NpgsqlSnakeCaseNameTranslator();

static readonly BackendTypes EmptyBackendTypes = new BackendTypes();

static readonly NpgsqlLogger Log = NpgsqlLogManager.GetCurrentClassLogger();

#endregion

#region Initialization and Loading

[RewriteAsync]

internal static void Setup(NpgsqlConnector connector, NpgsqlTimeout timeout)

{

// Note that there's a chicken and egg problem here - LoadBackendTypes below needs a functional

// connector to load the types, hence the strange initialization code here

connector.TypeHandlerRegistry = new TypeHandlerRegistry(connector);

BackendTypes types;

if (!BackendTypeCache.TryGetValue(connector.ConnectionString, out types))

types = BackendTypeCache[connector.ConnectionString] = LoadBackendTypes(connector, timeout);

connector.TypeHandlerRegistry._backendTypes = types;

connector.TypeHandlerRegistry.ActivateGlobalMappings();

}

TypeHandlerRegistry(NpgsqlConnector connector)

{

Connector = connector;

_backendTypes = EmptyBackendTypes;

UnrecognizedTypeHandler = new UnrecognizedTypeHandler();

ByOID = new Dictionary<uint, TypeHandler>();

_byDbType = new Dictionary<DbType, TypeHandler>();

_byNpgsqlDbType = new Dictionary<NpgsqlDbType, TypeHandler>();

_byType = new Dictionary<Type, TypeHandler> { [typeof(DBNull)] = UnrecognizedTypeHandler };

_byNpgsqlDbType[NpgsqlDbType.Unknown] = UnrecognizedTypeHandler;

}

internal void ActivateGlobalMappings()

{

if (_globalMappingActivationCounter == _globalMappingChangeCounter)

return;

foreach (var kv in _globalEnumMappings)

{

var backendType = GetBackendTypeByName(kv.Key);

var backendEnumType = backendType as BackendEnumType;

if (backendEnumType == null)

{

Log.Warn($"While attempting to activate global enum mappings, PostgreSQL type {kv.Key} was found but is not an enum. Skipping it.", Connector.Id);

continue;

}

backendEnumType.Activate(this, kv.Value);

}

foreach (var kv in _globalCompositeMappings)

{

try

{

GetCompositeType(kv.Key).Activate(this, kv.Value);

}

catch (Exception e)

{

Log.Warn("Caught an exception while attempting to activate global composite mappings", e, Connector.Id);

}

}

_globalMappingActivationCounter = _globalMappingChangeCounter;

}

static readonly string TypesQueryWithRange = GenerateTypesQuery(true);

static readonly string TypesQueryWithoutRange = GenerateTypesQuery(false);

static string GenerateTypesQuery(bool withRange)

{

// Select all types (base, array which is also base, enum, range, composite).

// Note that arrays are distinguished from primitive types through them having typreceive=array_recv.

// Order by primitives first, container later.

// For arrays and ranges, join in the element OID and type (to filter out arrays of unhandled

// types).

return

}

[RewriteAsync]

static BackendTypes LoadBackendTypes(NpgsqlConnector connector, NpgsqlTimeout timeout)

{

var types = new BackendTypes();

using (var command = new NpgsqlCommand(connector.SupportsRangeTypes ? TypesQueryWithRange : TypesQueryWithoutRange, connector.Connection))

{

command.CommandTimeout = timeout.IsSet ? (int)timeout.TimeLeft.TotalSeconds : 0;

command.AllResultTypesAreUnknown = true;

using (var reader = command.ExecuteReader())

{

while (reader.Read())

{

timeout.Check();

LoadBackendType(reader, types, connector);

}

}

}

return types;

}

static void LoadBackendType(NpgsqlDataReader reader, BackendTypes types, NpgsqlConnector connector)

{

var ns = reader.GetString(0);

var name = reader.GetString(1);

var oid = Convert.ToUInt32(reader[2]);

Contract.Assume(name != null);

Contract.Assume(oid != 0);

uint elementOID;

var typeChar = reader.GetString(5)[0];

switch (typeChar)

{

case 'b': // Normal base type

TypeAndMapping typeAndMapping;

(

HandlerTypes.TryGetValue(name, out typeAndMapping)

? new BackendBaseType(ns, name, oid, typeAndMapping.HandlerType, typeAndMapping.Mapping)

: new BackendBaseType(ns, name, oid) // Unsupported by Npgsql

).AddTo(types);

return;

case 'a': // Array

elementOID = Convert.ToUInt32(reader[6]);

Contract.Assume(elementOID > 0);

BackendType elementBackendType;

if (!types.ByOID.TryGetValue(elementOID, out elementBackendType))

{

Log.Trace($"Array type '{name}' refers to unknown element with OID {elementOID}, skipping", connector.Id);

return;

}

new BackendArrayType(ns, name, oid, elementBackendType).AddTo(types);

return;

case 'r': // Range

elementOID = Convert.ToUInt32(reader[6]);

Contract.Assume(elementOID > 0);

if (!types.ByOID.TryGetValue(elementOID, out elementBackendType))

{

Log.Trace($"Range type '{name}' refers to unknown subtype with OID {elementOID}, skipping", connector.Id);

return;

}

new BackendRangeType(ns, name, oid, elementBackendType).AddTo(types);

return;

case 'e': // Enum

new BackendEnumType(ns, name, oid).AddTo(types);

return;

case 'd': // Domain

var baseTypeOID = Convert.ToUInt32(reader[4]);

Contract.Assume(baseTypeOID > 0);

BackendType baseBackendType;

if (!types.ByOID.TryGetValue(baseTypeOID, out baseBackendType))

{

Log.Trace($"Domain type '{name}' refers to unknown base type with OID {baseTypeOID}, skipping", connector.Id);

return;

}

new BackendDomainType(ns, name, oid, baseBackendType).AddTo(types);

return;

case 'p': // pseudo-type (record, void)

// Hack this as a base type

goto case 'b';

default:

throw new ArgumentOutOfRangeException($"Unknown typtype for type '{name}' in pg_type: {typeChar}");

}

}

#endregion

#region Enum

internal void MapEnum<TEnum>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where TEnum : struct

{

if (nameTranslator == null)

nameTranslator = DefaultNameTranslator;

if (pgName == null)

pgName = GetPgName<TEnum>(nameTranslator);

var backendType = GetBackendTypeByName(pgName);

var asEnumType = backendType as BackendEnumType;

if (asEnumType == null)

throw new NpgsqlException($"A PostgreSQL type with the name {pgName} was found in the database but it isn't an enum");

asEnumType.Activate(this, new EnumHandler<TEnum>(backendType, nameTranslator));

}

internal static void MapEnumGlobally<TEnum>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where TEnum : struct

{

if (nameTranslator == null)

nameTranslator = DefaultNameTranslator;

if (pgName == null)

pgName = GetPgName<TEnum>(nameTranslator);

_globalMappingChangeCounter++;

_globalEnumMappings[pgName] = new EnumHandler<TEnum>.Factory(nameTranslator);

}

internal static void UnmapEnumGlobally<TEnum>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where TEnum : struct

{

if (nameTranslator == null)

nameTranslator = DefaultNameTranslator;

if (pgName == null)

pgName = GetPgName<TEnum>(nameTranslator);

_globalMappingChangeCounter++;

IEnumHandlerFactory _;

_globalEnumMappings.TryRemove(pgName, out _);

}

#endregion

#region Composite

internal void MapComposite<T>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where T : new()

{

if (nameTranslator == null)

nameTranslator = DefaultNameTranslator;

if (pgName == null)

pgName = GetPgName<T>(nameTranslator);

// TODO: Check if already mapped dude

var compositeType = GetCompositeType(pgName);

compositeType.Activate(this, new CompositeHandler<T>(compositeType, nameTranslator, this));

}

internal static void MapCompositeGlobally<T>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where T : new()

{

if (nameTranslator == null)

nameTranslator = DefaultNameTranslator;

if (pgName == null)

pgName = GetPgName<T>(nameTranslator);

_globalMappingChangeCounter++;

_globalCompositeMappings[pgName] = new CompositeHandler<T>.Factory(nameTranslator);

}

internal static void UnmapCompositeGlobally<T>([CanBeNull] string pgName, [CanBeNull] INpgsqlNameTranslator nameTranslator) where T : new()

{

if (nameTranslator == null)

nameTranslator = DefaultNameTranslator;

if (pgName == null)

pgName = GetPgName<T>(nameTranslator);

_globalMappingChangeCounter++;

ICompositeHandlerFactory _;

_globalCompositeMappings.TryRemove(pgName, out _);

}

#if WAT

const string LoadCompositeQuery =

const string LoadCompositeWithSchemaQuery =

#endif

static string GenerateLoadCompositeQuery(bool withSchema) =>

BackendCompositeType GetCompositeType(string pgName)

{

// First check if the composite type definition has already been loaded from the database

BackendType backendType;

if (pgName.IndexOf('.') == -1

? _backendTypes.ByName.TryGetValue(pgName, out backendType)

: _backendTypes.ByFullName.TryGetValue(pgName, out backendType))

{

var asComposite = backendType as BackendCompositeType;

if (asComposite == null)

throw new NpgsqlException($"Type {pgName} was found but is not a composite");

return asComposite;

}

// This is the first time the composite is mapped, the type definition needs to be loaded

string name, schema;

var i = pgName.IndexOf('.');

if (i == -1)

{

schema = null;

name = pgName;

}

else

{

schema = pgName.Substring(0, i);

name = pgName.Substring(i + 1);

}

using (var cmd = new NpgsqlCommand(GenerateLoadCompositeQuery(schema != null), Connector.Connection))

{

cmd.Parameters.AddWithValue("name", name);

if (schema != null)

cmd.Parameters.AddWithValue("schema", schema);

using (var reader = cmd.ExecuteReader())

{

if (!reader.Read())

throw new Exception($"An PostgreSQL type with the name {pgName} was not found in the database");

// Load some info on the composite type itself, do some checks

var ns = reader.GetString(0);

Contract.Assert(schema == null || ns == schema);

var oid = reader.GetFieldValue<uint>(1);

var typeChar = reader.GetChar(2);

if (typeChar != 'c')

throw new NpgsqlException($"Type {pgName} was found in the database but is not a composite");

reader.NextResult(); // Load the fields

var fields = new List<RawCompositeField>();

while (reader.Read())

fields.Add(new RawCompositeField { PgName = reader.GetString(0), TypeOID = reader.GetFieldValue<uint>(1) });

var compositeType = new BackendCompositeType(ns, name, oid, fields);

compositeType.AddTo(_backendTypes);

reader.NextResult(); // Load the array type

if (reader.Read())

{

var arrayNs = reader.GetString(0);

var arrayName = reader.GetString(1);

var arrayOID = reader.GetFieldValue<uint>(2);

new BackendArrayType(arrayNs, arrayName, arrayOID, compositeType).AddTo(_backendTypes);

} else

Log.Warn($"Could not find array type corresponding to composite {pgName}");

return compositeType;

}

}

}

#endregion

#region Lookups

/// <summary>

/// Looks up a type handler by its PostgreSQL type's OID.

/// </summary>

/// <param name="oid">A PostgreSQL type OID</param>

/// <returns>A type handler that can be used to encode and decode values.</returns>

internal TypeHandler this[uint oid]

{

get

{

TypeHandler result;

return TryGetByOID(oid, out result) ? result : UnrecognizedTypeHandler;

}

set { ByOID[oid] = value; }

}

internal bool TryGetByOID(uint oid, out TypeHandler handler)

{

if (ByOID.TryGetValue(oid, out handler))

return true;

BackendType backendType;

if (!_backendTypes.ByOID.TryGetValue(oid, out backendType))

return false;

handler = backendType.Activate(this);

return true;

}

internal TypeHandler this[NpgsqlDbType npgsqlDbType, Type specificType = null]

{

get

{

if (specificType != null && (npgsqlDbType & NpgsqlDbType.Enum) == 0 && (npgsqlDbType & NpgsqlDbType.Composite) == 0)

throw new ArgumentException($"{nameof(specificType)} can only be used with {nameof(NpgsqlDbType.Enum)} or {nameof(NpgsqlDbType.Composite)}");

Contract.EndContractBlock();

TypeHandler handler;

if (_byNpgsqlDbType.TryGetValue(npgsqlDbType, out handler)) {

return handler;

}

if (specificType != null) // Enum/composite

{

// Note that enums and composites are never lazily activated - they're activated at the

// moment of mapping (or at connection time when globally-mapped)

if ((npgsqlDbType & NpgsqlDbType.Array) != 0)

{

// Already-activated array of enum/composite

if (_arrayHandlerByType != null && _arrayHandlerByType.TryGetValue(specificType, out handler))

return handler;

}

// For non-array enum/composite, simply delegate to type inference

return this[specificType];

}

// Couldn't find already activated type, attempt to activate

if (npgsqlDbType == NpgsqlDbType.Enum || npgsqlDbType == NpgsqlDbType.Composite)

throw new InvalidCastException(string.Format("When specifying NpgsqlDbType.{0}, {0}Type must be specified as well",

npgsqlDbType == NpgsqlDbType.Enum ? "Enum" : "Composite"));

// Base, range or array of base/range

BackendType backendType;

if (_backendTypes.ByNpgsqlDbType.TryGetValue(npgsqlDbType, out backendType))

return backendType.Activate(this);

// We don't have a backend type for this NpgsqlDbType. This could be because it's not yet supported by

// Npgsql, or that the type is missing in the database (old PG, missing extension...)

TypeAndMapping typeAndMapping;

if (!HandlerTypesByNpsgqlDbType.TryGetValue(npgsqlDbType, out typeAndMapping))

throw new NotSupportedException("This NpgsqlDbType isn't supported in Npgsql yet: " + npgsqlDbType);

throw new NpgsqlException($"The PostgreSQL type '{typeAndMapping.Mapping.PgName}', mapped to NpgsqlDbType '{npgsqlDbType}' isn't present in your database. " +

"You may need to install an extension or upgrade to a newer version.");

}

}

internal TypeHandler this[DbType dbType]

{

get

{

Contract.Ensures(Contract.Result<TypeHandler>() != null);

TypeHandler handler;

if (_byDbType.TryGetValue(dbType, out handler))

return handler;

BackendType backendType;

if (_backendTypes.ByDbType.TryGetValue(dbType, out backendType))

return backendType.Activate(this);

throw new NotSupportedException("This DbType is not supported in Npgsql: " + dbType);

}

}

internal TypeHandler this[object value]

{

get

{

Contract.Requires(value != null);

Contract.Ensures(Contract.Result<TypeHandler>() != null);

if (value is DateTime)

{

return ((DateTime) value).Kind == DateTimeKind.Utc

? this[NpgsqlDbType.TimestampTZ]

: this[NpgsqlDbType.Timestamp];

}

if (value is NpgsqlDateTime) {

return ((NpgsqlDateTime)value).Kind == DateTimeKind.Utc

? this[NpgsqlDbType.TimestampTZ]

: this[NpgsqlDbType.Timestamp];

}

return this[value.GetType()];

}

}

internal TypeHandler this[Type type]

{

get

{

Contract.Ensures(Contract.Result<TypeHandler>() != null);

TypeHandler handler;

if (_byType.TryGetValue(type, out handler))

return handler;

Type arrayElementType = null;

// Detect arrays and generic ILists

if (type.IsArray)

arrayElementType = type.GetElementType();

else if (typeof(IList).IsAssignableFrom(type))

{

if (!type.GetTypeInfo().IsGenericType)

throw new NotSupportedException("Non-generic IList is a supported parameter, but the NpgsqlDbType parameter must be set on the parameter");

arrayElementType = type.GetGenericArguments()[0];

}

if (arrayElementType != null)

{

TypeHandler elementHandler;

if (_byType.TryGetValue(arrayElementType, out elementHandler) &&

elementHandler.BackendType.NpgsqlDbType.HasValue &&

_byNpgsqlDbType.TryGetValue(NpgsqlDbType.Array | elementHandler.BackendType.NpgsqlDbType.Value, out handler))

{

return handler;

}

// Enum and composite types go through the special _arrayHandlerByType

if (_arrayHandlerByType != null && _arrayHandlerByType.TryGetValue(arrayElementType, out handler))

return handler;

// Unactivated array

// Special check for byte[] - bytea not array of int2

if (type == typeof(byte[]))

{

BackendType byteaBackendType;

if (!_backendTypes.ByClrType.TryGetValue(typeof(byte[]), out byteaBackendType))

throw new NpgsqlException("The PostgreSQL 'bytea' type is missing");

return byteaBackendType.Activate(this);

}

// Get the elements backend type and activate its array backend type

BackendType elementBackendType;

if (!_backendTypes.ByClrType.TryGetValue(arrayElementType, out elementBackendType))

{

if (arrayElementType.GetTypeInfo().IsEnum)

throw new NotSupportedException($"The CLR enum type {arrayElementType.Name} must be mapped with Npgsql before usage, please refer to the documentation.");

throw new NotSupportedException($"The CLR type {arrayElementType} isn't supported by Npgsql or your PostgreSQL. " +

"If you wish to map it to a PostgreSQL composite type you need to register it before usage, please refer to the documentation.");

}

if (elementBackendType == null)

throw new NotSupportedException($"The PostgreSQL {arrayElementType.Name} does not have an array type in the database");

return elementBackendType.Array.Activate(this);

}

BackendType backendType;

// Try to find the backend type by a simple lookup on the given CLR type, this will handle base types.

if (_backendTypes.ByClrType.TryGetValue(type, out backendType))

return backendType.Activate(this);

// Range type which hasn't yet been set up

if (type.GetTypeInfo().IsGenericType && type.GetGenericTypeDefinition() == typeof(NpgsqlRange<>))

{

BackendType subtypeBackendType;

if (!_backendTypes.ByClrType.TryGetValue(type.GetGenericArguments()[0], out subtypeBackendType) ||

subtypeBackendType.Range == null)

{

throw new NpgsqlException($"The .NET range type {type.Name} isn't supported in your PostgreSQL, use CREATE TYPE AS RANGE");

}

return subtypeBackendType.Range.Activate(this);

}

// Nothing worked

if (type.GetTypeInfo().IsEnum)

throw new NotSupportedException($"The CLR enum type {type.Name} must be registered with Npgsql before usage, please refer to the documentation.");

if (typeof(IEnumerable).IsAssignableFrom(type))

throw new NotSupportedException("Npgsql 3.x removed support for writing a parameter with an IEnumerable value, use .ToList()/.ToArray() instead");

throw new NotSupportedException($"The CLR type {type} isn't supported by Npgsql or your PostgreSQL. " +

"If you wish to map it to a PostgreSQL composite type you need to register it before usage, please refer to the documentation.");

}

}

internal static NpgsqlDbType ToNpgsqlDbType(DbType dbType)

{

return DbTypeToNpgsqlDbType[dbType];

}

internal static NpgsqlDbType ToNpgsqlDbType(object value)

{

if (value is DateTime)

{

return ((DateTime)value).Kind == DateTimeKind.Utc

? NpgsqlDbType.TimestampTZ

: NpgsqlDbType.Timestamp;

}

if (value is NpgsqlDateTime)

{

return ((NpgsqlDateTime)value).Kind == DateTimeKind.Utc

? NpgsqlDbType.TimestampTZ

: NpgsqlDbType.Timestamp;

}

return ToNpgsqlDbType(value.GetType());

}

static NpgsqlDbType ToNpgsqlDbType(Type type)

{

NpgsqlDbType npgsqlDbType;

if (TypeToNpgsqlDbType.TryGetValue(type, out npgsqlDbType)) {

return npgsqlDbType;

}

if (type.IsArray)

{

if (type == typeof(byte[]))

return NpgsqlDbType.Bytea;

return NpgsqlDbType.Array | ToNpgsqlDbType(type.GetElementType());

}

var typeInfo = type.GetTypeInfo();

if (typeInfo.IsEnum)

return NpgsqlDbType.Enum;

if (typeInfo.IsGenericType && type.GetGenericTypeDefinition() == typeof(NpgsqlRange<>))

return NpgsqlDbType.Range | ToNpgsqlDbType(type.GetGenericArguments()[0]);

if (type == typeof(DBNull))

return NpgsqlDbType.Unknown;

throw new NotSupportedException("Can't infer NpgsqlDbType for type " + type);

}

internal static DbType ToDbType(Type type)

{

DbType dbType;

return TypeToDbType.TryGetValue(type, out dbType) ? dbType : DbType.Object;

}

internal static DbType ToDbType(NpgsqlDbType npgsqlDbType)

{

DbType dbType;

return NpgsqlDbTypeToDbType.TryGetValue(npgsqlDbType, out dbType) ? dbType : DbType.Object;

}

#endregion

#region Backend types

/// <summary>

/// A structure holding information about all PostgreSQL types found in an actual database.

/// Only contains <see cref="BackendType"/> instances and not actual <see cref="TypeHandlers"/>, and is shared between

/// all connections using the same connection string. Consulted when a type handler needs to be created.

/// </summary>

class BackendTypes

{

internal Dictionary<uint, BackendType> ByOID { get; } = new Dictionary<uint, BackendType>();

#if !__MonoCS__

/// <summary>

/// Indexes backend types by their PostgreSQL name, including namespace (e.g. pg_catalog.int4).

/// Only used for enums and composites.

/// </summary>

#endif

internal Dictionary<string, BackendType> ByFullName { get; } = new Dictionary<string, BackendType>();

#if !__MonoCS__

/// <summary>

/// Indexes backend types by their PostgreSQL name, not including namespace.

/// If more than one type exists with the same name (i.e. in different namespaces) this

/// table will contain an entry with a null value.

/// Only used for enums and composites.

/// </summary>

#endif

internal Dictionary<string, BackendType> ByName { get; } = new Dictionary<string, BackendType>();

internal Dictionary<NpgsqlDbType, BackendType> ByNpgsqlDbType { get; } = new Dictionary<NpgsqlDbType, BackendType>();

internal Dictionary<DbType, BackendType> ByDbType { get; } = new Dictionary<DbType, BackendType>();

internal Dictionary<Type, BackendType> ByClrType { get; } = new Dictionary<Type, BackendType>();

}

/// <summary>

/// Represents a single PostgreSQL data type, as discovered from pg_type.

/// Note that this simply a data structure describing a type and not a handler, and is shared between connectors

/// having the same connection string.

/// </summary>

abstract class BackendType : IBackendType

{

protected BackendType(string ns, string name, uint oid)

{

Namespace = ns;

Name = name;

FullName = Namespace + '.' + Name;

DisplayName = Namespace == "pg_catalog"

? Name

: FullName;

OID = oid;

}

public string Namespace { get; }

public string Name { get; }

public uint OID { get; }

public NpgsqlDbType? NpgsqlDbType { get; protected set; }

public string FullName { get; }

public string DisplayName { get; }

internal BackendArrayType Array;

internal BackendRangeType Range;

/// <summary>

/// For base types, contains the handler type.

/// If null, this backend type isn't supported by Npgsql.

/// </summary>

[CanBeNull]

internal Type HandlerType;

internal virtual void AddTo(BackendTypes types)

{

types.ByOID[OID] = this;

if (NpgsqlDbType != null)

types.ByNpgsqlDbType[NpgsqlDbType.Value] = this;

}

internal abstract TypeHandler Activate(TypeHandlerRegistry registry);

/// <summary>

/// Returns a string that represents the current object.

/// </summary>

public override string ToString() => DisplayName;

}

class BackendBaseType : BackendType

{

readonly DbType[] _dbTypes;

readonly Type[] _clrTypes;