-
Notifications
You must be signed in to change notification settings - Fork 874
Expand file tree
/
Copy pathPostgresType.cs
More file actions
133 lines (110 loc) · 4.87 KB
/
PostgresType.cs
File metadata and controls
133 lines (110 loc) · 4.87 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
using System;
using System.Diagnostics.CodeAnalysis;
using Npgsql.Internal.Postgres;
namespace Npgsql.PostgresTypes;
/// <summary>
/// Represents a PostgreSQL data type, such as int4 or text, as discovered from pg_type.
/// This class is abstract, see derived classes for concrete types of PostgreSQL types.
/// </summary>
/// <remarks>
/// Instances of this class are shared between connections to the same databases.
/// For more info about what this class and its subclasses represent, see
/// https://www.postgresql.org/docs/current/static/catalog-pg-type.html.
/// </remarks>
public abstract class PostgresType
{
#region Constructors
/// <summary>
/// Constructs a representation of a PostgreSQL data type.
/// </summary>
/// <param name="ns">The data type's namespace (or schema).</param>
/// <param name="name">The data type's display name.</param>
/// <param name="oid">The data type's OID.</param>
private protected PostgresType(string ns, string name, uint oid)
{
DataTypeName = DataTypeName.FromDisplayName(ns is null or "pg_catalog" ? name : ns + "." + name);
OID = oid;
}
/// <summary>
/// Constructs a representation of a PostgreSQL data type.
/// </summary>
/// <param name="dataTypeName">The data type's fully qualified name.</param>
/// <param name="oid">The data type's OID.</param>
private protected PostgresType(DataTypeName dataTypeName, Oid oid)
{
DataTypeName = dataTypeName;
OID = oid.Value;
}
#endregion
#region Public Properties
/// <summary>
/// The data type's OID - a unique id identifying the data type in a given database (in pg_type).
/// </summary>
public uint OID { get; }
/// <summary>
/// The data type's namespace (or schema).
/// </summary>
public string Namespace => DataTypeName.Schema;
/// <summary>
/// The data type's name.
/// </summary>
/// <remarks>
/// Note that this is the standard, user-displayable type name (e.g. integer[]) rather than the internal
/// PostgreSQL name as it is in pg_type (_int4). See <see cref="InternalName"/> for the latter.
/// </remarks>
public string Name => DataTypeName.UnqualifiedDisplayName;
/// <summary>
/// The full name of the backend type, including its namespace.
/// </summary>
[field: MaybeNull]
public string FullName => field ??= Namespace + "." + Name;
internal DataTypeName DataTypeName { get; }
/// <summary>
/// A display name for this backend type, including the namespace unless it is pg_catalog (the namespace
/// for all built-in types).
/// </summary>
public string DisplayName => DataTypeName.DisplayName;
/// <summary>
/// The data type's internal PostgreSQL name (e.g. <c>_int4</c> not <c>integer[]</c>).
/// See <see cref="Name"/> for a more user-friendly name.
/// </summary>
public string InternalName => DataTypeName.UnqualifiedName;
/// <summary>
/// If a PostgreSQL array type exists for this type, it will be referenced here.
/// Otherwise null.
/// </summary>
public PostgresArrayType? Array { get; internal set; }
/// <summary>
/// If a PostgreSQL range type exists for this type, it will be referenced here.
/// Otherwise null.
/// </summary>
public PostgresRangeType? Range { get; internal set; }
#endregion
internal virtual string GetPartialNameWithFacets(int typeModifier) => Name;
/// <summary>
/// Generates the type name including any facts (size, precision, scale), given the PostgreSQL type modifier.
/// </summary>
internal string GetDisplayNameWithFacets(int typeModifier)
=> Namespace == "pg_catalog"
? GetPartialNameWithFacets(typeModifier)
: Namespace + '.' + GetPartialNameWithFacets(typeModifier);
internal virtual PostgresFacets GetFacets(int typeModifier) => PostgresFacets.None;
/// <summary>
/// Returns a string that represents the current object.
/// </summary>
public override string ToString() => DisplayName;
PostgresType? _representationalType;
/// Canonizes (nested) domain types to underlying types, does not handle composites.
internal PostgresType GetRepresentationalType()
{
return _representationalType ??= Core(this) ?? throw new InvalidOperationException("Couldn't map type to representational type");
static PostgresType? Core(PostgresType? postgresType)
=> (postgresType as PostgresDomainType)?.BaseType ?? postgresType switch
{
PostgresArrayType { Element: PostgresDomainType domain } => Core(domain.BaseType)?.Array,
PostgresMultirangeType { Subrange.Subtype: PostgresDomainType domain } => domain.BaseType.Range?.Multirange,
PostgresRangeType { Subtype: PostgresDomainType domain } => domain.Range,
var type => type
};
}
}