using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Data.Common;

using System.Diagnostics;

using System.IO;

using System.Net.Security;

using System.Net.Sockets;

using System.Runtime.CompilerServices;

using System.Security.Cryptography.X509Certificates;

using System.Threading;

using System.Threading.Tasks;

using System.Transactions;

using JetBrains.Annotations;

using Npgsql.Logging;

using Npgsql.NameTranslation;

using Npgsql.TypeMapping;

using Npgsql.Util;

using NpgsqlTypes;

using IsolationLevel = System.Data.IsolationLevel;

namespace Npgsql

/// <summary>

/// This class represents a connection to a PostgreSQL server.

/// </summary>

// ReSharper disable once RedundantNameQualifier

[System.ComponentModel.DesignerCategory("")]

public sealed class NpgsqlConnection : DbConnection, ICloneable

{

#region Fields

// Set this when disposed is called.

bool _disposed;

/// <summary>

/// The connection string, without the password after open (unless Persist Security Info=true)

/// </summary>

string _userFacingConnectionString = string.Empty;

/// <summary>

/// The original connection string provided by the user, including the password.

/// </summary>

string _connectionString = string.Empty;

internal string OriginalConnectionString => _connectionString;

/// <summary>

/// The connector object connected to the backend.

/// </summary>

internal NpgsqlConnector? Connector;

/// <summary>

/// The parsed connection string set by the user

/// </summary>

internal NpgsqlConnectionStringBuilder Settings { get; private set; } = DefaultSettings;

static readonly NpgsqlConnectionStringBuilder DefaultSettings = new NpgsqlConnectionStringBuilder();

ConnectorPool? _pool;

bool _wasBroken;

internal Transaction? EnlistedTransaction { get; set; }

/// <summary>

/// The global type mapper, which contains defaults used by all new connections.

/// Modify mappings on this mapper to affect your entire application.

/// </summary>

public static INpgsqlTypeMapper GlobalTypeMapper => TypeMapping.GlobalTypeMapper.Instance;

/// <summary>

/// The connection-specific type mapper - all modifications affect this connection only,

/// and are lost when it is closed.

/// </summary>

public INpgsqlTypeMapper TypeMapper => CheckReadyAndGetConnector().TypeMapper;

///

/// <summary>

/// The default TCP/IP port for PostgreSQL.

/// </summary>

public const int DefaultPort = 5432;

/// <summary>

/// Maximum value for connection timeout.

/// </summary>

internal const int TimeoutLimit = 1024;

static readonly NpgsqlLogger Log = NpgsqlLogManager.CreateLogger(nameof(NpgsqlConnection));

static bool _countersInitialized;

static readonly StateChangeEventArgs ClosedToOpenEventArgs = new StateChangeEventArgs(ConnectionState.Closed, ConnectionState.Open);

static readonly StateChangeEventArgs OpenToClosedEventArgs = new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed);

#endregion Fields

#region Constructors / Init / Open

/// <summary>

/// Initializes a new instance of the

/// <see cref="NpgsqlConnection">NpgsqlConnection</see> class.

/// </summary>

public NpgsqlConnection()

=> GC.SuppressFinalize(this);

/// <summary>

/// Initializes a new instance of <see cref="NpgsqlConnection"/> with the given connection string.

/// </summary>

/// <param name="connectionString">The connection used to open the PostgreSQL database.</param>

public NpgsqlConnection(string connectionString) : this()

=> ConnectionString = connectionString;

/// <summary>

/// Opens a database connection with the property settings specified by the

/// <see cref="ConnectionString">ConnectionString</see>.

/// </summary>

public override void Open() => Open(false, CancellationToken.None).GetAwaiter().GetResult();

/// <summary>

/// This is the asynchronous version of <see cref="Open()"/>.

/// </summary>

/// <remarks>

/// Do not invoke other methods and properties of the <see cref="NpgsqlConnection"/> object until the returned Task is complete.

/// </remarks>

/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>

/// <returns>A task representing the asynchronous operation.</returns>

public override Task OpenAsync(CancellationToken cancellationToken)

}

void GetPoolAndSettings()

}

Task Open(bool async, CancellationToken cancellationToken)

}

#endregion Open / Init

#region Connection string management

/// <summary>

/// Gets or sets the string used to connect to a PostgreSQL database. See the manual for details.

/// </summary>

/// <value>The connection string that includes the server name,

/// the database name, and other parameters needed to establish

/// the initial connection. The default value is an empty string.

/// </value>

#nullable disable

public override string ConnectionString

}

/// <summary>

/// Gets or sets the delegate used to generate a password for new database connections.

/// </summary>

/// <remarks>

/// This delegate is executed when a new database connection is opened that requires a password.

/// <see cref="NpgsqlConnectionStringBuilder.Password">Password</see> and

/// <see cref="NpgsqlConnectionStringBuilder.Passfile">Passfile</see> connection string

/// properties have precedence over this delegate. It will not be executed if a password is

/// specified, or the specified or default Passfile contains a valid entry.

/// Due to connection pooling this delegate is only executed when a new physical connection

/// is opened, not when reusing a connection that was previously opened from the pool.

/// </remarks>

public ProvidePasswordCallback? ProvidePasswordCallback { get; set; }

#endregion Connection string management

#region Configuration settings

/// <summary>

/// Backend server host name.

/// </summary>

[Browsable(true)]

[PublicAPI]

public string? Host => Settings.Host;

/// <summary>

/// Backend server port.

/// </summary>

[Browsable(true)]

[PublicAPI]

public int Port => Settings.Port;

/// <summary>

/// Gets the time (in seconds) to wait while trying to establish a connection

/// before terminating the attempt and generating an error.

/// </summary>

/// <value>The time (in seconds) to wait for a connection to open. The default value is 15 seconds.</value>

public override int ConnectionTimeout => Settings.Timeout;

/// <summary>

/// Gets the time (in seconds) to wait while trying to execute a command

/// before terminating the attempt and generating an error.

/// </summary>

/// <value>The time (in seconds) to wait for a command to complete. The default value is 20 seconds.</value>

public int CommandTimeout => Settings.CommandTimeout;

///<summary>

/// Gets the name of the current database or the database to be used after a connection is opened.

/// </summary>

/// <value>The name of the current database or the name of the database to be

/// used after a connection is opened. The default value is the empty string.</value>

public override string? Database => Settings.Database ?? Settings.Username;

/// <summary>

/// Gets the string identifying the database server (host and port)

/// </summary>

public override string DataSource => Settings.DataSourceCached;

/// <summary>

/// Whether to use Windows integrated security to log in.

/// </summary>

[PublicAPI]

public bool IntegratedSecurity => Settings.IntegratedSecurity;

/// <summary>

/// User name.

/// </summary>

[PublicAPI]

public string? UserName => Settings.Username;

internal string? Password => Settings.Password;

// The following two lines are here for backwards compatibility with the EF6 provider

// ReSharper disable UnusedMember.Global

internal string? EntityTemplateDatabase => Settings.EntityTemplateDatabase;

internal string? EntityAdminDatabase => Settings.EntityAdminDatabase;

// ReSharper restore UnusedMember.Global

#endregion Configuration settings

#region State management

/// <summary>

/// Gets the current state of the connection.

/// </summary>

/// <value>A bitwise combination of the <see cref="System.Data.ConnectionState">ConnectionState</see> values. The default is <b>Closed</b>.</value>

[Browsable(false)]

public ConnectionState FullState

}

/// <summary>

/// Gets whether the current state of the connection is Open or Closed

/// </summary>

/// <value>ConnectionState.Open, ConnectionState.Closed or ConnectionState.Connecting</value>

[Browsable(false)]

public override ConnectionState State

}

#endregion State management

#region Commands

/// <summary>

/// Creates and returns a <see cref="System.Data.Common.DbCommand">DbCommand</see>

/// object associated with the <see cref="System.Data.Common.DbConnection">IDbConnection</see>.

/// </summary>

/// <returns>A <see cref="System.Data.Common.DbCommand">DbCommand</see> object.</returns>

protected override DbCommand CreateDbCommand()

{

return CreateCommand();

}

/// <summary>

/// Creates and returns a <see cref="NpgsqlCommand">NpgsqlCommand</see>

/// object associated with the <see cref="NpgsqlConnection">NpgsqlConnection</see>.

/// </summary>

/// <returns>A <see cref="NpgsqlCommand">NpgsqlCommand</see> object.</returns>

public new NpgsqlCommand CreateCommand()

}

#endregion Commands

#region Transactions

/// <summary>

/// Begins a database transaction with the specified isolation level.

/// </summary>

/// <param name="isolationLevel">The <see cref="System.Data.IsolationLevel">isolation level</see> under which the transaction should run.</param>

/// <returns>An <see cref="System.Data.Common.DbTransaction">DbTransaction</see>

/// object representing the new transaction.</returns>

/// <remarks>

/// Currently the IsolationLevel ReadCommitted and Serializable are supported by the PostgreSQL backend.

/// There's no support for nested transactions.

/// </remarks>

protected override DbTransaction BeginDbTransaction(IsolationLevel isolationLevel)

{

return BeginTransaction(isolationLevel);

}

/// <summary>

/// Begins a database transaction.

/// </summary>

/// <returns>A <see cref="NpgsqlTransaction">NpgsqlTransaction</see>

/// object representing the new transaction.</returns>

/// <remarks>

/// Currently there's no support for nested transactions. Transactions created by this method will have Read Committed isolation level.

/// </remarks>

public new NpgsqlTransaction BeginTransaction() => BeginTransaction(IsolationLevel.Unspecified);

/// <summary>

/// Begins a database transaction with the specified isolation level.

/// </summary>

/// <param name="level">The <see cref="System.Data.IsolationLevel">isolation level</see> under which the transaction should run.</param>

/// <returns>A <see cref="NpgsqlTransaction">NpgsqlTransaction</see>

/// object representing the new transaction.</returns>

/// <remarks>

/// Currently the IsolationLevel ReadCommitted and Serializable are supported by the PostgreSQL backend.

/// There's no support for nested transactions.

/// </remarks>

public new NpgsqlTransaction BeginTransaction(IsolationLevel level)

}

/// <summary>

/// Enlist transaction.

/// </summary>

#nullable disable

public override void EnlistTransaction(Transaction transaction)

}

#endregion

#region Close

/// <summary>

/// Releases the connection. If the connection is pooled, it will be returned to the pull and made available for re-use.

/// If it is non-pooled, the physical connection will be closed.

/// </summary>

public override void Close() => Close(wasBroken: false, async: false);

/// <summary>

/// Releases the connection. If the connection is pooled, it will be returned to the pull and made available for re-use.

/// If it is non-pooled, the physical connection will be closed.

/// </summary>

#if !NET461 && !NETSTANDARD2_0

public override Task CloseAsync()

#else

public Task CloseAsync()

}

internal Task Close(bool wasBroken, bool async)

}

/// <summary>

/// Releases all resources used by the <see cref="NpgsqlConnection">NpgsqlConnection</see>.

/// </summary>

/// <param name="disposing"><b>true</b> when called from Dispose();

/// <b>false</b> when being called from the finalizer.</param>

protected override void Dispose(bool disposing)

}

/// <summary>

/// Releases all resources used by the <see cref="NpgsqlConnection">NpgsqlConnection</see>.

/// </summary>

#if !NET461 && !NETSTANDARD2_0

public async override ValueTask DisposeAsync()

#else

public async ValueTask DisposeAsync()

}

#endregion

#region Notifications and Notices

/// <summary>

/// Fires when PostgreSQL notices are received from PostgreSQL.

/// </summary>

/// <remarks>

/// PostgreSQL notices are non-critical messages generated by PostgreSQL, either as a result of a user query

/// (e.g. as a warning or informational notice), or due to outside activity (e.g. if the database administrator

/// initiates a "fast" database shutdown).

///

/// Note that notices are very different from notifications (see the <see cref="Notification"/> event).

/// </remarks>

public event NoticeEventHandler? Notice;

/// <summary>

/// Fires when PostgreSQL notifications are received from PostgreSQL.

/// </summary>

/// <remarks>

/// PostgreSQL notifications are sent when your connection has registered for notifications on a specific channel via the

/// LISTEN command. NOTIFY can be used to generate such notifications, allowing for an inter-connection communication channel.

///

/// Note that notifications are very different from notices (see the <see cref="Notice"/> event).

/// </remarks>

public event NotificationEventHandler? Notification;

internal void OnNotice(PostgresNotice e)

}

internal void OnNotification(NpgsqlNotificationEventArgs e)

}

#endregion Notifications and Notices

#region SSL

/// <summary>

/// Returns whether SSL is being used for the connection.

/// </summary>

internal bool IsSecure => CheckConnectionOpen().IsSecure;

/// <summary>

/// Selects the local Secure Sockets Layer (SSL) certificate used for authentication.

/// </summary>

/// <remarks>

/// See <see href="https://msdn.microsoft.com/en-us/library/system.net.security.localcertificateselectioncallback(v=vs.110).aspx"/>

/// </remarks>

public ProvideClientCertificatesCallback? ProvideClientCertificatesCallback { get; set; }

/// <summary>

/// Verifies the remote Secure Sockets Layer (SSL) certificate used for authentication.

/// Ignored if <see cref="NpgsqlConnectionStringBuilder.TrustServerCertificate"/> is set.

/// </summary>

/// <remarks>

/// See <see href="https://msdn.microsoft.com/en-us/library/system.net.security.remotecertificatevalidationcallback(v=vs.110).aspx"/>

/// </remarks>

public RemoteCertificateValidationCallback? UserCertificateValidationCallback { get; set; }

#endregion SSL

#region Backend version, capabilities, settings

/// <summary>

/// Version of the PostgreSQL backend.

/// This can only be called when there is an active connection.

/// </summary>

[Browsable(false)]

public Version PostgreSqlVersion => CheckConnectionOpen().DatabaseInfo.Version;

/// <summary>

/// PostgreSQL server version.

/// </summary>

public override string ServerVersion => PostgreSqlVersion.ToString();

/// <summary>

/// Process id of backend server.

/// This can only be called when there is an active connection.

/// </summary>

[Browsable(false)]

// ReSharper disable once InconsistentNaming

public int ProcessID => CheckConnectionOpen().BackendProcessId;

/// <summary>

/// Reports whether the backend uses the newer integer timestamp representation.

/// Note that the old floating point representation is not supported.

/// Meant for use by type plugins (e.g. NodaTime)

/// </summary>

[Browsable(false)]

[PublicAPI]

public bool HasIntegerDateTimes => CheckConnectionOpen().DatabaseInfo.HasIntegerDateTimes;

/// <summary>

/// The connection's timezone as reported by PostgreSQL, in the IANA/Olson database format.

/// </summary>

[Browsable(false)]

[PublicAPI]

public string Timezone => CheckConnectionOpen().Timezone;

/// <summary>

/// Holds all PostgreSQL parameters received for this connection. Is updated if the values change

/// (e.g. as a result of a SET command).

/// </summary>

[Browsable(false)]

[PublicAPI]

public IReadOnlyDictionary<string, string> PostgresParameters => CheckConnectionOpen().PostgresParameters;

#endregion Backend version, capabilities, settings

#region Copy

/// <summary>

/// Begins a binary COPY FROM STDIN operation, a high-performance data import mechanism to a PostgreSQL table.

/// </summary>

/// <param name="copyFromCommand">A COPY FROM STDIN SQL command</param>

/// <returns>A <see cref="NpgsqlBinaryImporter"/> which can be used to write rows and columns</returns>

/// <remarks>

/// See http://www.postgresql.org/docs/current/static/sql-copy.html.

/// </remarks>

public NpgsqlBinaryImporter BeginBinaryImport(string copyFromCommand)

}

/// <summary>

/// Begins a binary COPY TO STDOUT operation, a high-performance data export mechanism from a PostgreSQL table.

/// </summary>

/// <param name="copyToCommand">A COPY TO STDOUT SQL command</param>

/// <returns>A <see cref="NpgsqlBinaryExporter"/> which can be used to read rows and columns</returns>

/// <remarks>

/// See http://www.postgresql.org/docs/current/static/sql-copy.html.

/// </remarks>

public NpgsqlBinaryExporter BeginBinaryExport(string copyToCommand)

}

/// <summary>

/// Begins a textual COPY FROM STDIN operation, a data import mechanism to a PostgreSQL table.

/// It is the user's responsibility to send the textual input according to the format specified

/// in <paramref name="copyFromCommand"/>.

/// </summary>

/// <param name="copyFromCommand">A COPY FROM STDIN SQL command</param>

/// <returns>

/// A TextWriter that can be used to send textual data.</returns>

/// <remarks>

/// See http://www.postgresql.org/docs/current/static/sql-copy.html.

/// </remarks>

public TextWriter BeginTextImport(string copyFromCommand)

}

/// <summary>

/// Begins a textual COPY TO STDOUT operation, a data export mechanism from a PostgreSQL table.

/// It is the user's responsibility to parse the textual input according to the format specified

/// in <paramref name="copyToCommand"/>.

/// </summary>

/// <param name="copyToCommand">A COPY TO STDOUT SQL command</param>

/// <returns>

/// A TextReader that can be used to read textual data.</returns>

/// <remarks>

/// See http://www.postgresql.org/docs/current/static/sql-copy.html.

/// </remarks>

public TextReader BeginTextExport(string copyToCommand)

}

/// <summary>

/// Begins a raw binary COPY operation (TO STDOUT or FROM STDIN), a high-performance data export/import mechanism to a PostgreSQL table.

/// Note that unlike the other COPY API methods, <see cref="BeginRawBinaryCopy"/> doesn't implement any encoding/decoding

/// and is unsuitable for structured import/export operation. It is useful mainly for exporting a table as an opaque

/// blob, for the purpose of importing it back later.

/// </summary>

/// <param name="copyCommand">A COPY TO STDOUT or COPY FROM STDIN SQL command</param>

/// <returns>A <see cref="NpgsqlRawCopyStream"/> that can be used to read or write raw binary data.</returns>

/// <remarks>

/// See http://www.postgresql.org/docs/current/static/sql-copy.html.

/// </remarks>

public NpgsqlRawCopyStream BeginRawBinaryCopy(string copyCommand)

}

#endregion

#region Enum mapping

/// <summary>

/// Maps a CLR enum to a PostgreSQL enum type for use with this connection.