/// <inheritdoc />

public async Task<NpgsqlDatabaseInfo?> Load(NpgsqlConnector conn, NpgsqlTimeout timeout, bool async)

{

var db = new PostgresDatabaseInfo(conn);

await db.LoadPostgresInfo(conn, timeout, async).ConfigureAwait(false);

Debug.Assert(db.LongVersion != null);

return db;

}

readonly ILogger _connectionLogger;

/// <summary>

/// The PostgreSQL types detected in the database.

/// </summary>

List<PostgresType>? _types;

/// <inheritdoc />

protected override IEnumerable<PostgresType> GetTypes() => _types ?? (IEnumerable<PostgresType>)Array.Empty<PostgresType>();

/// <summary>

/// The PostgreSQL version string as returned by the version() function. Populated during loading.

/// </summary>

public string LongVersion { get; set; } = default!;

/// <summary>

/// True if the backend is Amazon Redshift; otherwise, false.

/// </summary>

public bool IsRedshift { get; private set; }

/// <inheritdoc />

public override bool SupportsUnlisten => Version.IsGreaterOrEqual(6, 4) && !IsRedshift;

/// <summary>

/// True if the 'pg_enum' table includes the 'enumsortorder' column; otherwise, false.

/// </summary>

public virtual bool HasEnumSortOrder => Version.IsGreaterOrEqual(9, 1);

/// <summary>

/// True if the 'pg_type' table includes the 'typcategory' column; otherwise, false.

/// </summary>

/// <remarks>

/// pg_type.typcategory is added after 8.4.

/// see: https://www.postgresql.org/docs/8.4/static/catalog-pg-type.html#CATALOG-TYPCATEGORY-TABLE

/// </remarks>

public virtual bool HasTypeCategory => Version.IsGreaterOrEqual(8, 4);

internal PostgresDatabaseInfo(NpgsqlConnector conn)

: base(conn.Host!, conn.Port, conn.Database!, conn.PostgresParameters["server_version"])

=> _connectionLogger = conn.LoggingConfiguration.ConnectionLogger;

private protected PostgresDatabaseInfo(string host, int port, string databaseName, string serverVersion)

: base(host, port, databaseName, serverVersion)

=> _connectionLogger = NullLogger.Instance;

/// <summary>

/// Loads database information from the PostgreSQL database specified by <paramref name="conn"/>.

/// </summary>

/// <param name="conn">The database connection.</param>

/// <param name="timeout">The timeout while loading types from the backend.</param>

/// <param name="async">True to load types asynchronously.</param>

/// <returns>

/// A task representing the asynchronous operation.

/// </returns>

internal async Task LoadPostgresInfo(NpgsqlConnector conn, NpgsqlTimeout timeout, bool async)

{

HasIntegerDateTimes =

conn.PostgresParameters.TryGetValue("integer_datetimes", out var intDateTimes) &&

intDateTimes == "on";

IsRedshift = conn.Settings.ServerCompatibilityMode == ServerCompatibilityMode.Redshift;

_types = await LoadBackendTypes(conn, timeout, async).ConfigureAwait(false);

}

/// <summary>

/// Generates a raw SQL query string to select type information.

/// </summary>

/// <remarks>

/// 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).

/// </remarks>

static string GenerateLoadTypesQuery(bool withRange, bool withMultirange, bool loadTableComposites)

=> $@"

static string GenerateLoadCompositeTypesQuery(bool loadTableComposites)

=> $@"

static string GenerateLoadEnumFieldsQuery(bool withEnumSortOrder)

=> $@"

/// <summary>

/// Loads type information from the backend specified by <paramref name="conn"/>.

/// </summary>

/// <param name="conn">The database connection.</param>

/// <param name="timeout">The timeout while loading types from the backend.</param>

/// <param name="async">True to load types asynchronously.</param>

/// <returns>

/// A collection of types loaded from the backend.

/// </returns>

/// <exception cref="TimeoutException" />

/// <exception cref="ArgumentOutOfRangeException">Unknown typtype for type '{internalName}' in pg_type: {typeChar}.</exception>

internal async Task<List<PostgresType>> LoadBackendTypes(NpgsqlConnector conn, NpgsqlTimeout timeout, bool async)

{

var versionQuery = "SELECT version();";

var loadTypesQuery = GenerateLoadTypesQuery(SupportsRangeTypes, SupportsMultirangeTypes, conn.Settings.LoadTableComposites);

var loadCompositeTypesQuery = GenerateLoadCompositeTypesQuery(conn.Settings.LoadTableComposites);

var loadEnumFieldsQuery = SupportsEnumTypes

? GenerateLoadEnumFieldsQuery(HasEnumSortOrder)

: string.Empty;

timeout.CheckAndApply(conn);

// The Lexer (https://github.com/postgres/postgres/blob/master/src/backend/replication/repl_scanner.l)

// and Parser (https://github.com/postgres/postgres/blob/master/src/backend/replication/repl_gram.y)

// for replication connections are pretty picky and somewhat flawed.

// Currently (2022-01-22) they do not support

// - SQL batches containing multiple commands

// - The <CR> ('\r') in Windows or Mac newlines

// - Comments

// For this reason we need clean up our type loading queries for replication connections and execute

// them individually instead of batched.

// Theoretically we cold even use the extended protocol + batching for regular (non-replication)

// connections but that would branch our code even more for very little gain.

var isReplicationConnection = conn.Settings.ReplicationMode != ReplicationMode.Off;

if (isReplicationConnection)

{

await conn.WriteQuery(versionQuery, async).ConfigureAwait(false);

await conn.WriteQuery(SanitizeForReplicationConnection(loadTypesQuery), async).ConfigureAwait(false);

await conn.WriteQuery(SanitizeForReplicationConnection(loadCompositeTypesQuery), async).ConfigureAwait(false);

if (SupportsEnumTypes)

await conn.WriteQuery(SanitizeForReplicationConnection(loadEnumFieldsQuery), async).ConfigureAwait(false);

static string SanitizeForReplicationConnection(string str)

{

var sb = new StringBuilder(str.Length);

using var c = str.GetEnumerator();

while (c.MoveNext())

{

switch (c.Current)

{

case '\r':

sb.Append('\n');

// Check for a \n after the \r

// and swallow it if it exists

if (c.MoveNext())

{

if (c.Current == '-')

goto case '-';

if (c.Current != '\n')

sb.Append(c.Current);

}

break;

case '-':

// Check if there is a second dash

if (c.MoveNext())

{

if (c.Current == '\r')

{

sb.Append('-');

goto case '\r';

}

if (c.Current != '-')

{

sb.Append('-');

sb.Append(c.Current);

break;

}

// Comment mode

// Swallow everything until we find a newline

while (c.MoveNext())

{

if (c.Current == '\r')

goto case '\r';

if (c.Current == '\n')

{

sb.Append('\n');

break;

}

}

}

break;

default:

sb.Append(c.Current);

break;

}

}

return sb.ToString();

}

}

else

{

var batchQuery = new StringBuilder(

versionQuery.Length +

loadTypesQuery.Length +

loadCompositeTypesQuery.Length +

(SupportsEnumTypes

? loadEnumFieldsQuery.Length

: 0))

.AppendLine(versionQuery)

.AppendLine(loadTypesQuery)

.AppendLine(loadCompositeTypesQuery);

if (SupportsEnumTypes)

batchQuery.AppendLine(loadEnumFieldsQuery);

await conn.WriteQuery(batchQuery.ToString(), async).ConfigureAwait(false);

}

await conn.Flush(async).ConfigureAwait(false);

var byOID = new Dictionary<uint, PostgresType>();

// First read the PostgreSQL version

Expect<RowDescriptionMessage>(await conn.ReadMessage(async).ConfigureAwait(false), conn);

// We read the message in non-sequential mode which buffers the whole message.

// There is no need to ensure data within the message boundaries

Expect<DataRowMessage>(await conn.ReadMessage(async).ConfigureAwait(false), conn);

// Note that here and below we don't assign ReadBuffer to a variable

// because we might allocate oversize buffer

conn.ReadBuffer.Skip(2); // Column count

LongVersion = ReadNonNullableString(conn.ReadBuffer);

Expect<CommandCompleteMessage>(await conn.ReadMessage(async).ConfigureAwait(false), conn);

if (isReplicationConnection)

Expect<ReadyForQueryMessage>(await conn.ReadMessage(async).ConfigureAwait(false), conn);

// Then load the types

Expect<RowDescriptionMessage>(await conn.ReadMessage(async).ConfigureAwait(false), conn);

IBackendMessage msg;

while (true)

{

msg = await conn.ReadMessage(async).ConfigureAwait(false);

if (msg is not DataRowMessage)

break;

conn.ReadBuffer.Skip(2); // Column count

var nspname = ReadNonNullableString(conn.ReadBuffer);

var oid = uint.Parse(ReadNonNullableString(conn.ReadBuffer), NumberFormatInfo.InvariantInfo);

Debug.Assert(oid != 0);

var typname = ReadNonNullableString(conn.ReadBuffer);

var typtype = ReadNonNullableString(conn.ReadBuffer)[0];

var typnotnull = ReadNonNullableString(conn.ReadBuffer)[0] == 't';

var len = conn.ReadBuffer.ReadInt32();

var elemtypoid = len == -1 ? 0 : uint.Parse(conn.ReadBuffer.ReadString(len), NumberFormatInfo.InvariantInfo);

switch (typtype)

{

case 'b': // Normal base type

var baseType = new PostgresBaseType(nspname, typname, oid);

byOID[baseType.OID] = baseType;

continue;

case 'a': // Array

{

Debug.Assert(elemtypoid > 0);

if (!byOID.TryGetValue(elemtypoid, out var elementPostgresType))

{

_connectionLogger.LogTrace("Array type '{ArrayTypeName}' refers to unknown element with OID {ElementTypeOID}, skipping",

typname, elemtypoid);

continue;

}

var arrayType = new PostgresArrayType(nspname, typname, oid, elementPostgresType);

byOID[arrayType.OID] = arrayType;

continue;