#region License

#endregion

using System;

using System.Collections.Concurrent;

using System.ComponentModel;

using System.Data;

using System.Data.Common;

using System.Diagnostics.Contracts;

using System.IO;

using System.Net.Security;

using System.Reflection;

using System.Security.Cryptography;

using System.Security.Cryptography.X509Certificates;

using System.Threading;

#if !DNXCORE50

using System.Transactions;

#endif

using Npgsql.Logging;

using IsolationLevel = System.Data.IsolationLevel;

namespace Npgsql

/// <summary>

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

/// </summary>

#if WITHDESIGN

[System.Drawing.ToolboxBitmapAttribute(typeof(NpgsqlConnection))]

#endif

#if DNXCORE50

public sealed class NpgsqlConnection : DbConnection

#else

[System.ComponentModel.DesignerCategory("")]

public sealed class NpgsqlConnection : DbConnection, ICloneable

#endif

{

#region Fields

// Set this when disposed is called.

bool _disposed;

// Used when we closed the connector due to an error, but are pretending it's open.

bool _fakingOpen;

// Used when the connection is closed but an TransactionScope is still active

// (the actual close is postponed until the scope ends)

bool _postponingClose;

bool _postponingDispose;

/// <summary>

/// The parsed connection string set by the user

/// </summary>

internal NpgsqlConnectionStringBuilder Settings { get; private set; }

/// <summary>

/// The actual string provided by the user for the connection string

/// </summary>

string _connectionString;

/// <summary>

/// The connector object connected to the backend.

/// </summary>

internal NpgsqlConnector Connector { get; set; }

/// <summary>

/// A counter that gets incremented every time the connection is (re-)opened.

/// This allows us to identify an "instance" of connection, which is useful since

/// some resources are released when a connection is closed (e.g. prepared statements).

/// </summary>

internal int OpenCounter { get; private set; }

internal bool WasBroken { get; set; }

#if !DNXCORE50

NpgsqlPromotableSinglePhaseNotification Promotable

{

get { return _promotable ?? (_promotable = new NpgsqlPromotableSinglePhaseNotification(this)); }

}

NpgsqlPromotableSinglePhaseNotification _promotable;

#endif

/// <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 ConcurrentDictionary<string, NpgsqlConnectionStringBuilder> BuilderCache = new ConcurrentDictionary<string, NpgsqlConnectionStringBuilder>();

static readonly NpgsqlLogger Log = NpgsqlLogManager.GetCurrentClassLogger();

#endregion Fields

#region Constructors / Init / Open

/// <summary>

/// Initializes a new instance of the

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

/// </summary>

public NpgsqlConnection() : this(String.Empty) {}

/// <summary>

/// Initializes a new instance of the

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

/// and sets the <see cref="NpgsqlConnection.ConnectionString">ConnectionString</see>.

/// </summary>

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

public NpgsqlConnection(NpgsqlConnectionStringBuilder builder) : this(builder.ConnectionString) { }

/// <summary>

/// Initializes a new instance of the

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

/// and sets the <see cref="NpgsqlConnection.ConnectionString">ConnectionString</see>.

/// </summary>

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

public NpgsqlConnection(string connectionString)

}

void Init()

}

/// <summary>

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

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

/// </summary>

public override void Open()

}

#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>

#if WITHDESIGN

[RefreshProperties(RefreshProperties.All), DefaultValue(""), RecommendedAsConfigurable(true)]

[NpgsqlSysDescription("Description_ConnectionString", typeof(NpgsqlConnection)), Category("Data")]

[Editor(typeof(ConnectionStringEditor), typeof(System.Drawing.Design.UITypeEditor))]

#endif

public override string ConnectionString

}

#endregion Connection string management

#region Configuration settings

/// <summary>

/// Backend server host name.

/// </summary>

#if !DNXCORE50

[Browsable(true)]

#endif

public string Host { get { return Settings.Host; } }

/// <summary>

/// Backend server port.

/// </summary>

#if !DNXCORE50

[Browsable(true)]

#endif

public int Port { get { return Settings.Port; } }

/// <summary>

/// If true, the connection will attempt to use SslStream instead of an internal TlsClientStream.

/// </summary>

public bool UseSslStream { get { return Settings.UseSslStream; } }

/// <summary>

/// Gets the time 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>

#if WITHDESIGN

[NpgsqlSysDescription("Description_ConnectionTimeout", typeof(NpgsqlConnection))]

#endif

public override int ConnectionTimeout { get { return Settings.Timeout; } }

/// <summary>

/// Gets the time 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 { get { return Settings.CommandTimeout; } }

/// <summary>

/// Gets the time to wait before closing unused connections in the pool if the count

/// of all connections exeeds MinPoolSize.

/// </summary>

/// <remarks>

/// If connection pool contains unused connections for ConnectionLifeTime seconds,

/// the half of them will be closed. If there will be unused connections in a second

/// later then again the half of them will be closed and so on.

/// This strategy provide smooth change of connection count in the pool.

/// </remarks>

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

public int ConnectionLifeTime { get { return Settings.ConnectionLifeTime; } }

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

#if WITHDESIGN

[NpgsqlSysDescription("Description_Database", typeof(NpgsqlConnection))]

#endif

public override string Database { get { return Settings.Database; } }

/// <summary>

/// Gets the database server name.

/// </summary>

public override string DataSource { get { return Settings.Host; } }

/// <summary>

/// Gets flag indicating if we are using Synchronous notification or not.

/// The default value is false.

/// </summary>

public bool ContinuousProcessing { get { return Settings.ContinuousProcessing; } }

/// <summary>

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

/// </summary>

public bool IntegratedSecurity { get { return Settings.IntegratedSecurity; } }

/// <summary>

/// User name.

/// </summary>

public string UserName { get { return Settings.Username; } }

/// <summary>

/// Determine if connection pooling will be used for this connection.

/// </summary>

internal bool Pooling { get { return Settings.Pooling; } }

internal int MinPoolSize { get { return Settings.MinPoolSize; } }

internal int MaxPoolSize { get { return Settings.MaxPoolSize; } }

internal int Timeout { get { return Settings.Timeout; } }

internal bool Enlist { get { return Settings.Enlist; } }

internal int BufferSize { get { return Settings.BufferSize; } }

internal string EntityTemplateDatabase { get { return Settings.EntityTemplateDatabase; } }

#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>

#if !DNXCORE50

[Browsable(false)]

#endif

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>

#if !DNXCORE50

[Browsable(false)]

#endif

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.

/// </remarks>

public new NpgsqlTransaction BeginTransaction()

{

return 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>

/// When a connection is closed within an enclosing TransactionScope and the transaction

/// hasn't been promoted, we defer the actual closing until the scope ends.

/// </summary>

internal void PromotableLocalTransactionEnded()

}

#if !DNXCORE50

/// <summary>

/// Enlist transation.

/// </summary>

/// <param name="transaction"></param>

public override void EnlistTransaction(Transaction transaction)

{

Promotable.Enlist(transaction);

}

#endif

#endregion

#region Close

internal void EmergencyClose()

{

_fakingOpen = true;

}

/// <summary>

/// Releases the connection to the database. If the connection is pooled, it will be

/// made available for re-use. If it is non-pooled, the actual connection will be shutdown.

/// </summary>

public override void Close()

}

internal void ReallyClose()

}

/// <summary>

/// Closes ongoing operations, i.e. an open reader exists or a COPY operation still in progress, as

/// part of a connection close.

/// Does nothing if the thread has been aborted - the connector will be closed immediately.

/// </summary>

void CloseOngoingOperations()

}

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

}

#endregion

#region Notifications

/// <summary>

/// Occurs on NoticeResponses from the PostgreSQL backend.

/// </summary>

public event NoticeEventHandler Notice;

internal NoticeEventHandler NoticeDelegate;

/// <summary>

/// Occurs on NotificationResponses from the PostgreSQL backend.

/// </summary>

public event NotificationEventHandler Notification;

internal NotificationEventHandler NotificationDelegate;

//

// Internal methods and properties

//

internal void OnNotice(object o, NpgsqlNoticeEventArgs e)

}

internal void OnNotification(object o, NpgsqlNotificationEventArgs e)

}

#endregion Notifications

#region SSL

/// <summary>

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

/// </summary>

internal bool 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 and capabilities

/// <summary>

/// Version of the PostgreSQL backend.

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

/// </summary>

#if !DNXCORE50

[Browsable(false)]

#endif

public Version PostgreSqlVersion

}

/// <summary>

/// PostgreSQL server version.

/// </summary>

public override string ServerVersion

{

get { return PostgreSqlVersion.ToString(); }

}

internal bool IsRedshift

}

/// <summary>

/// Process id of backend server.

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

/// </summary>

#if !DNXCORE50

[Browsable(false)]

#endif

// ReSharper disable once InconsistentNaming

public int ProcessID

}

/// <summary>

/// Report whether the backend is expecting standard conformant strings.

/// In version 8.1, Postgres began reporting this value (false), but did not actually support standard conformant strings.

/// In version 8.2, Postgres began supporting standard conformant strings, but defaulted this flag to false.

/// As of version 9.1, this flag defaults to true.

/// </summary>

#if !DNXCORE50

[Browsable(false)]

#endif

public bool UseConformantStrings

}

/// <summary>

/// Report whether the backend understands the string literal E prefix (>= 8.1).

/// </summary>

#if !DNXCORE50

[Browsable(false)]

#endif

// ReSharper disable once InconsistentNaming

public bool Supports_E_StringPrefix

}

/// <summary>

/// Report whether the backend understands the hex byte format (>= 9.0).

/// </summary>

#if !DNXCORE50

[Browsable(false)]

#endif

public bool SupportsHexByteFormat

}

#endregion Backend version and capabilities

#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 STDIN operation, a high-performance data export mechanism from a PostgreSQL table.

/// </summary>

/// <param name="copyToCommand">A COPY TO STDIN 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 FROM STDIN operation, a data import mechanism to 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 STDIN 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 or FROM), 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 FROM STDIN or COPY TO 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)

}