#region License

#endregion

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Data.Common;

using System.Linq;

using System.Runtime.CompilerServices;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using System.Diagnostics.Contracts;

using System.Globalization;

using System.Net.Sockets;

using AsyncRewriter;

using JetBrains.Annotations;

using Npgsql.BackendMessages;

using Npgsql.FrontendMessages;

using Npgsql.Logging;

namespace Npgsql

/// <summary>

/// Represents a SQL statement or function (stored procedure) to execute

/// against a PostgreSQL database. This class cannot be inherited.

/// </summary>

#if WITHDESIGN

[System.Drawing.ToolboxBitmapAttribute(typeof(NpgsqlCommand)), ToolboxItem(true)]

#endif

#if NETSTANDARD1_3

public sealed partial class NpgsqlCommand : DbCommand

#else

// ReSharper disable once RedundantNameQualifier

[System.ComponentModel.DesignerCategory("")]

public sealed partial class NpgsqlCommand : DbCommand, ICloneable

#endif

{

#region Fields

NpgsqlConnection _connection;

/// <summary>

/// Cached version of _connection.Connector, for performance

/// </summary>

NpgsqlConnector _connector;

NpgsqlTransaction _transaction;

String _commandText;

int? _timeout;

readonly NpgsqlParameterCollection _parameters = new NpgsqlParameterCollection();

List<NpgsqlStatement> _statements;

/// <summary>

/// Returns details about each statement that this command has executed.

/// Is only populated when an Execute* method is called.

/// </summary>

public IReadOnlyList<NpgsqlStatement> Statements => _statements.AsReadOnly();

int _readStatementIndex;

int _writeStatementIndex;

/// <summary>

/// If part of the send happens asynchronously (see <see cref="SendRemaining"/>,

/// the Task for that remaining send is stored here.

/// </summary>

internal Task RemainingSendTask;

UpdateRowSource _updateRowSource = UpdateRowSource.Both;

/// <summary>

/// Indicates whether this command has been prepared.

/// Never access this field directly, use <see cref="IsPrepared"/> instead.

/// </summary>

bool _isPrepared;

/// <summary>

/// For prepared commands, captures the connection's <see cref="NpgsqlConnection.OpenCounter"/>

/// at the time the command was prepared. This allows us to know whether the connection was

/// closed since the command was prepared.

/// </summary>

int _prepareConnectionOpenId;

static readonly NpgsqlLogger Log = NpgsqlLogManager.GetCurrentClassLogger();

#endregion Fields

#region Constants

internal const int DefaultTimeout = 30;

#endregion

#region Constructors

/// <summary>

/// Initializes a new instance of the <see cref="NpgsqlCommand">NpgsqlCommand</see> class.

/// </summary>

public NpgsqlCommand() : this(string.Empty, null, null) {}

/// <summary>

/// Initializes a new instance of the <see cref="NpgsqlCommand">NpgsqlCommand</see> class with the text of the query.

/// </summary>

/// <param name="cmdText">The text of the query.</param>

// ReSharper disable once IntroduceOptionalParameters.Global

public NpgsqlCommand(string cmdText) : this(cmdText, null, null) {}

/// <summary>

/// Initializes a new instance of the <see cref="NpgsqlCommand">NpgsqlCommand</see> class with the text of the query and a <see cref="NpgsqlConnection">NpgsqlConnection</see>.

/// </summary>

/// <param name="cmdText">The text of the query.</param>

/// <param name="connection">A <see cref="NpgsqlConnection">NpgsqlConnection</see> that represents the connection to a PostgreSQL server.</param>

// ReSharper disable once IntroduceOptionalParameters.Global

public NpgsqlCommand(string cmdText, NpgsqlConnection connection) : this(cmdText, connection, null) {}

/// <summary>

/// Initializes a new instance of the <see cref="NpgsqlCommand">NpgsqlCommand</see> class with the text of the query, a <see cref="NpgsqlConnection">NpgsqlConnection</see>, and the <see cref="NpgsqlTransaction">NpgsqlTransaction</see>.

/// </summary>

/// <param name="cmdText">The text of the query.</param>

/// <param name="connection">A <see cref="NpgsqlConnection">NpgsqlConnection</see> that represents the connection to a PostgreSQL server.</param>

/// <param name="transaction">The <see cref="NpgsqlTransaction">NpgsqlTransaction</see> in which the <see cref="NpgsqlCommand">NpgsqlCommand</see> executes.</param>

public NpgsqlCommand(string cmdText, [CanBeNull] NpgsqlConnection connection, [CanBeNull] NpgsqlTransaction transaction)

}

void Init(string cmdText)

}

#endregion Constructors

#region Public properties

/// <summary>

/// Gets or sets the SQL statement or function (stored procedure) to execute at the data source.

/// </summary>

/// <value>The Transact-SQL statement or stored procedure to execute. The default is an empty string.</value>

[DefaultValue("")]

[Category("Data")]

public override string CommandText

}

/// <summary>

/// Gets or sets the wait time before terminating the attempt to execute a command and generating an error.

/// </summary>

/// <value>The time (in seconds) to wait for the command to execute. The default value is 30 seconds.</value>

[DefaultValue(DefaultTimeout)]

public override int CommandTimeout

}

/// <summary>

/// Gets or sets a value indicating how the

/// <see cref="NpgsqlCommand.CommandText">CommandText</see> property is to be interpreted.

/// </summary>

/// <value>One of the <see cref="System.Data.CommandType">CommandType</see> values. The default is <see cref="System.Data.CommandType">CommandType.Text</see>.</value>

[DefaultValue(CommandType.Text)]

[Category("Data")]

public override CommandType CommandType { get; set; }

/// <summary>

/// DB connection.

/// </summary>

protected override DbConnection DbConnection

}

/// <summary>

/// Gets or sets the <see cref="NpgsqlConnection">NpgsqlConnection</see>

/// used by this instance of the <see cref="NpgsqlCommand">NpgsqlCommand</see>.

/// </summary>

/// <value>The connection to a data source. The default value is a null reference.</value>

[DefaultValue(null)]

[Category("Behavior")]

public new NpgsqlConnection Connection

}

/// <summary>

/// Design time visible.

/// </summary>

public override bool DesignTimeVisible { get; set; }

/// <summary>

/// Gets or sets how command results are applied to the DataRow when used by the

/// DbDataAdapter.Update(DataSet) method.

/// </summary>

/// <value>One of the <see cref="System.Data.UpdateRowSource">UpdateRowSource</see> values.</value>

[Category("Behavior"), DefaultValue(UpdateRowSource.Both)]

public override UpdateRowSource UpdatedRowSource

}

/// <summary>

/// Returns whether this query will execute as a prepared (compiled) query.

/// </summary>

public bool IsPrepared

}

#endregion Public properties

#region Known/unknown Result Types Management

/// <summary>

/// Marks all of the query's result columns as either known or unknown.

/// Unknown results column are requested them from PostgreSQL in text format, and Npgsql makes no

/// attempt to parse them. They will be accessible as strings only.

/// </summary>

public bool AllResultTypesAreUnknown

}

bool _allResultTypesAreUnknown;

/// <summary>

/// Marks the query's result columns as known or unknown, on a column-by-column basis.

/// Unknown results column are requested them from PostgreSQL in text format, and Npgsql makes no

/// attempt to parse them. They will be accessible as strings only.

/// </summary>

/// <remarks>

/// If the query includes several queries (e.g. SELECT 1; SELECT 2), this will only apply to the first

/// one. The rest of the queries will be fetched and parsed as usual.

///

/// The array size must correspond exactly to the number of result columns the query returns, or an

/// error will be raised.

/// </remarks>

public bool[] UnknownResultTypeList

}

bool[] _unknownResultTypeList;

#endregion

#region Result Types Management

/// <summary>

/// Marks result types to be used when using GetValue on a data reader, on a column-by-column basis.

/// Used for Entity Framework 5-6 compability.

/// Only primitive numerical types and DateTimeOffset are supported.

/// Set the whole array or just a value to null to use default type.

/// </summary>

internal Type[] ObjectResultTypes { get; set; }

#endregion

#region State management

int _state;

/// <summary>

/// Gets the current state of the connector

/// </summary>

internal CommandState State

}

SendState _sendState;

#endregion State management

#region Parameters

/// <summary>

/// Creates a new instance of an <see cref="System.Data.Common.DbParameter">DbParameter</see> object.

/// </summary>

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

protected override DbParameter CreateDbParameter()

{

return CreateParameter();

}

/// <summary>

/// Creates a new instance of a <see cref="NpgsqlParameter">NpgsqlParameter</see> object.

/// </summary>

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

public new NpgsqlParameter CreateParameter()

{

return new NpgsqlParameter();

}

/// <summary>

/// DB parameter collection.

/// </summary>

protected override DbParameterCollection DbParameterCollection => Parameters;

/// <summary>

/// Gets the <see cref="NpgsqlParameterCollection">NpgsqlParameterCollection</see>.

/// </summary>

/// <value>The parameters of the SQL statement or function (stored procedure). The default is an empty collection.</value>

#if WITHDESIGN

[Category("Data"), DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

#endif

public new NpgsqlParameterCollection Parameters => _parameters;

#endregion

#region Prepare

/// <summary>

/// Creates a prepared version of the command on a PostgreSQL server.

/// </summary>

public override void Prepare()

}

void DeallocatePrepared()

}

#endregion Prepare

#region Query analysis

void ProcessRawQuery()

}

#endregion

#region Execute

void Validate()

}

[RewriteAsync]

NpgsqlDataReader Execute(CommandBehavior behavior = CommandBehavior.Default)

}

#endregion

#region Send

delegate bool PopulateMethod(ref DirectBuffer directBuf);

[RewriteAsync]

void Send(PopulateMethod populateMethod)

}

/// <summary>

/// This method is used to asynchronously sends all remaining protocol messages for statements

/// beyond the first one, and *without* waiting for the send to complete. This technique is

/// used to avoid the deadlock described in #641 by allowing the user to read query results

/// while at the same time sending messages for later statements.

/// </summary>

async Task SendRemaining(PopulateMethod populateMethod, CancellationToken cancellationToken)

}

#endregion

#region Message Creation / Population

/// <summary>

/// Populates the send buffer with protocol messages for the execution of non-prepared statement(s).

/// </summary>

/// <returns>

/// true whether all messages could be populated in the buffer, false otherwise (method needs to be

/// called again)

/// </returns>

bool PopulateExecuteNonPrepared(ref DirectBuffer directBuf)

}

/// <summary>

/// Populates the send buffer with protocol messages for the execution of prepared statement(s).

/// </summary>

/// <returns>

/// true whether all messages could be populated in the buffer, false otherwise (method needs to be

/// called again)

/// </returns>

bool PopulateExecutePrepared(ref DirectBuffer directBuf)

}

/// <summary>

/// Populates the send buffer with Parse/Describe protocol messages, used for preparing commands

/// and for execution in SchemaOnly mode.

/// </summary>

/// <returns>

/// true whether all messages could be populated in the buffer, false otherwise (method needs to be

/// called again)

/// </returns>

bool PopulatePrepare(ref DirectBuffer directBuf) => PopulateParseDescribe(true);

/// <summary>

/// Populates the send buffer with Parse/Describe protocol messages, used for preparing commands

/// and for execution in SchemaOnly mode.

/// </summary>

/// <returns>

/// true whether all messages could be populated in the buffer, false otherwise (method needs to be

/// called again)

/// </returns>

bool PopulateExecuteSchemaOnly(ref DirectBuffer directBuf) => PopulateParseDescribe(false);

bool PopulateParseDescribe(bool isPreparing)

}

bool PopulateDeallocate(ref DirectBuffer directBuf)

}

#endregion

#region Execute Non Query

/// <summary>

/// Executes a SQL statement against the connection and returns the number of rows affected.

/// </summary>

/// <returns>The number of rows affected if known; -1 otherwise.</returns>

public override int ExecuteNonQuery() => ExecuteNonQueryInternal();

/// <summary>

/// Asynchronous version of <see cref="ExecuteNonQuery"/>

/// </summary>

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

/// <returns>A task representing the asynchronous operation, with the number of rows affected if known; -1 otherwise.</returns>

public override async Task<int> ExecuteNonQueryAsync(CancellationToken cancellationToken)

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

[RewriteAsync]

int ExecuteNonQueryInternal()

}

#endregion Execute Non Query

#region Execute Scalar

/// <summary>

/// Executes the query, and returns the first column of the first row

/// in the result set returned by the query. Extra columns or rows are ignored.

/// </summary>

/// <returns>The first column of the first row in the result set,

/// or a null reference if the result set is empty.</returns>

[CanBeNull]

public override object ExecuteScalar() => ExecuteScalarInternal();

/// <summary>

/// Asynchronous version of <see cref="ExecuteScalar"/>

/// </summary>

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

/// <returns>A task representing the asynchronous operation, with the first column of the

/// first row in the result set, or a null reference if the result set is empty.</returns>

public override async Task<object> ExecuteScalarAsync(CancellationToken cancellationToken)

}

[MethodImpl(MethodImplOptions.AggressiveInlining)]

[RewriteAsync]

[CanBeNull]

object ExecuteScalarInternal()

}

#endregion Execute Scalar

#region Execute Reader

/// <summary>

/// Executes the CommandText against the Connection, and returns an DbDataReader.