{

EnableSqlRewriting = !AppContext.TryGetSwitch("Npgsql.EnableSqlRewriting", out var enabled) || enabled;

EnableStoredProcedureCompatMode = AppContext.TryGetSwitch("Npgsql.EnableStoredProcedureCompatMode", out enabled) && enabled;

{

GC.SuppressFinalize(this);

InternalBatchCommands = new List<NpgsqlBatchCommand>(1);

_commandText = cmdText ?? string.Empty;

InternalConnection = connection;

CommandType = CommandType.Text;

{

GC.SuppressFinalize(this);

InternalBatchCommands = new List<NpgsqlBatchCommand>(batchCommandCapacity);

InternalConnection = connection;

CommandType = CommandType.Text;

IsWrappedByBatch = true;

// These can/should never be used in this mode

_commandText = null!;

_parameters = null!;

{

get => _commandText;

set

{

Debug.Assert(!IsWrappedByBatch);

if (State != CommandState.Idle)

ThrowHelper.ThrowInvalidOperationException("An open data reader exists for this command.");

_commandText = value ?? string.Empty;

ResetPreparation();

// TODO: Technically should do this also if the parameter list (or type) changes

}

{

get => _timeout ?? (InternalConnection?.CommandTimeout ?? DefaultTimeout);

set

{

if (value < 0) {

throw new ArgumentOutOfRangeException(nameof(value), value, "CommandTimeout can't be less than zero.");

}

_timeout = value;

}

{

get => InternalConnection;

set

{

if (InternalConnection == value)

return;

InternalConnection = State == CommandState.Idle

? (NpgsqlConnection?)value

: throw new InvalidOperationException("An open data reader exists for this command.");

Transaction = null;

}

{

get => (NpgsqlConnection?)DbConnection;

set => DbConnection = value;

{

get => _updateRowSource;

set

{

switch (value)

{

// validate value (required based on base type contract)

case UpdateRowSource.None:

case UpdateRowSource.OutputParameters:

case UpdateRowSource.FirstReturnedRecord:

case UpdateRowSource.Both:

_updateRowSource = value;

break;

default:

throw new ArgumentOutOfRangeException();

}

}

{

get

{

return _connectorPreparedOn == (InternalConnection?.Connector ?? _connector) && AllPrepared();

bool AllPrepared()

{

if (InternalBatchCommands.Count is 0)

return false;

foreach (var s in InternalBatchCommands)

if (s.PreparedStatement is null || !s.PreparedStatement.IsPrepared)

return false;

return true;

}

}

{

get => _allResultTypesAreUnknown;

set

{

// TODO: Check that this isn't modified after calling prepare

_unknownResultTypeList = null;

_allResultTypesAreUnknown = value;

}

{

get => _unknownResultTypeList;

set

{

// TODO: Check that this isn't modified after calling prepare

_allResultTypesAreUnknown = false;

_unknownResultTypeList = value;

}

{

get => (CommandState)_state;

set

{

var newState = (int)value;

if (newState == _state)

return;

_state = newState;

}

{

var conn = CheckAndGetConnection();

Debug.Assert(conn is not null);

if (string.IsNullOrEmpty(CommandText))

throw new InvalidOperationException("CommandText property has not been initialized");

using var _ = conn.StartTemporaryBindingScope(out var connector);

foreach (var s in InternalBatchCommands)

if (s.PreparedStatement?.IsExplicit == true)

throw new NpgsqlException("Deriving parameters isn't supported for commands that are already prepared.");

// Here we unprepare statements that possibly are auto-prepared

Unprepare();

Parameters.Clear();

switch (CommandType)

{

case CommandType.Text:

DeriveParametersForQuery(connector);

break;

case CommandType.StoredProcedure:

DeriveParametersForFunction();

break;

default:

throw new NotSupportedException("Cannot derive parameters for CommandType " + CommandType);

}

{

using var c = new NpgsqlCommand(DeriveParametersForFunctionQuery, InternalConnection);

c.Parameters.Add(new NpgsqlParameter("proname", NpgsqlDbType.Text));

c.Parameters[0].Value = CommandText;

string[]? names = null;

uint[]? types = null;

char[]? modes = null;

using (var rdr = c.ExecuteReader(CommandBehavior.SingleRow | CommandBehavior.SingleResult))

{

if (rdr.Read())

{

if (!rdr.IsDBNull(0))

names = rdr.GetFieldValue<string[]>(0);

if (!rdr.IsDBNull(2))

types = rdr.GetFieldValue<uint[]>(2);

if (!rdr.IsDBNull(3))

modes = rdr.GetFieldValue<char[]>(3);

if (types == null)

{

if (rdr.IsDBNull(1) || rdr.GetFieldValue<uint[]>(1).Length == 0)

return; // Parameter-less function

types = rdr.GetFieldValue<uint[]>(1);

}

}

else

throw new InvalidOperationException($"{CommandText} does not exist in pg_proc");

}

var serializerOptions = c.InternalConnection!.Connector!.SerializerOptions;

for (var i = 0; i < types.Length; i++)

{

var param = new NpgsqlParameter();

var postgresType = serializerOptions.DatabaseInfo.GetPostgresType(types[i]);

var npgsqlDbType = postgresType.DataTypeName.ToNpgsqlDbType();

param.DataTypeName = postgresType.DisplayName;

param.PostgresType = postgresType;

if (npgsqlDbType.HasValue)

param.NpgsqlDbType = npgsqlDbType.Value;

if (names != null && i < names.Length)

param.ParameterName = names[i];

else

param.ParameterName = "parameter" + (i + 1);

if (modes == null) // All params are IN, or server < 8.1.0 (and only IN is supported)

param.Direction = ParameterDirection.Input;

else

{

param.Direction = modes[i] switch

{

'i' => ParameterDirection.Input,

'o' => ParameterDirection.Output,

't' => ParameterDirection.Output,

'b' => ParameterDirection.InputOutput,

'v' => throw new NotSupportedException("Cannot derive function parameter of type VARIADIC"),

_ => throw new ArgumentOutOfRangeException("Unknown code in proargmodes while deriving: " + modes[i])

};

}

Parameters.Add(param);

}

{

using (connector.StartUserAction())

{

LogMessages.DerivingParameters(connector.CommandLogger, CommandText, connector.Id);

if (IsWrappedByBatch)

foreach (var batchCommand in InternalBatchCommands)

connector.SqlQueryParser.ParseRawQuery(batchCommand, connector.UseConformingStrings, deriveParameters: true);

else

connector.SqlQueryParser.ParseRawQuery(this, connector.UseConformingStrings, deriveParameters: true);

var sendTask = SendDeriveParameters(connector, false);

if (sendTask.IsFaulted)

sendTask.GetAwaiter().GetResult();

try

{

foreach (var batchCommand in InternalBatchCommands)

{

Expect<ParseCompleteMessage>(

connector.ReadMessage(async: false).GetAwaiter().GetResult(), connector);

var paramTypeOIDs = Expect<ParameterDescriptionMessage>(

connector.ReadMessage(async: false).GetAwaiter().GetResult(), connector).TypeOIDs;

if (batchCommand.PositionalParameters.Count != paramTypeOIDs.Count)

{

connector.SkipUntil(BackendMessageCode.ReadyForQuery);

Parameters.Clear();

throw new NpgsqlException(

"There was a mismatch in the number of derived parameters between the Npgsql SQL parser and the PostgreSQL parser. Please report this as bug to the Npgsql developers (https://github.com/npgsql/npgsql/issues).");

}

for (var i = 0; i < paramTypeOIDs.Count; i++)

{

try

{

var param = batchCommand.PositionalParameters[i];

var paramOid = paramTypeOIDs[i];

var postgresType = connector.SerializerOptions.DatabaseInfo.GetPostgresType(paramOid);

// We want to keep any domain types visible on the parameter, it will internally do a representational lookup again if necessary.

var npgsqlDbType = postgresType.GetRepresentationalType().DataTypeName.ToNpgsqlDbType();

if (param.NpgsqlDbType != NpgsqlDbType.Unknown && param.NpgsqlDbType != npgsqlDbType)

throw new NpgsqlException(

"The backend parser inferred different types for parameters with the same name. Please try explicit casting within your SQL statement or batch or use different placeholder names.");

param.DataTypeName = postgresType.DisplayName;

param.PostgresType = postgresType;

if (npgsqlDbType.HasValue)

param.NpgsqlDbType = npgsqlDbType.Value;

}

catch

{

connector.SkipUntil(BackendMessageCode.ReadyForQuery);

Parameters.Clear();

throw;

}

}

var msg = connector.ReadMessage(async: false).GetAwaiter().GetResult();

switch (msg.Code)

{

case BackendMessageCode.RowDescription:

case BackendMessageCode.NoData:

break;

default:

throw connector.UnexpectedMessageReceived(msg.Code);

}

}

Expect<ReadyForQueryMessage>(connector.ReadMessage(async: false).GetAwaiter().GetResult(), connector);

}

finally

{

try

{

// Make sure sendTask is complete so we don't race against asynchronous flush

sendTask.GetAwaiter().GetResult();

}

catch

{

// ignored

}

}

}

{

var connection = CheckAndGetConnection();

Debug.Assert(connection is not null);

if (connection.Settings.Multiplexing)

throw new NotSupportedException("Explicit preparation not supported with multiplexing");

var connector = connection.Connector!;

var logger = connector.CommandLogger;

var needToPrepare = false;

if (IsWrappedByBatch)

{

foreach (var batchCommand in InternalBatchCommands)

{

batchCommand._parameters?.ProcessParameters(connector.SerializerOptions, validateValues: false, CommandType);

ProcessRawQuery(connector.SqlQueryParser, connector.UseConformingStrings, batchCommand);

needToPrepare = batchCommand.ExplicitPrepare(connector) || needToPrepare;

}

if (logger.IsEnabled(LogLevel.Debug) && needToPrepare)

LogMessages.PreparingCommandExplicitly(logger, string.Join("; ", CommandTexts()), connector.Id);

IEnumerable<string> CommandTexts()

{

foreach (var c in InternalBatchCommands)

yield return c.CommandText;

}

}

else

{

_parameters?.ProcessParameters(connector.SerializerOptions, validateValues: false, CommandType);

ProcessRawQuery(connector.SqlQueryParser, connector.UseConformingStrings, batchCommand: null);

foreach (var batchCommand in InternalBatchCommands)

needToPrepare = batchCommand.ExplicitPrepare(connector) || needToPrepare;

if (logger.IsEnabled(LogLevel.Debug) && needToPrepare)

LogMessages.PreparingCommandExplicitly(logger, CommandText, connector.Id);

}

_connectorPreparedOn = connector;

// It's possible the command was already prepared, or that persistent prepared statements were found for

// all statements. Nothing to do here, move along.

return needToPrepare

? PrepareLong(this, async, connector, cancellationToken)

: Task.CompletedTask;

static async Task PrepareLong(NpgsqlCommand command, bool async, NpgsqlConnector connector, CancellationToken cancellationToken)

{

try

{

using (connector.StartUserAction(cancellationToken))

{

var sendTask = command.SendPrepare(connector, async, CancellationToken.None);

if (sendTask.IsFaulted)

sendTask.GetAwaiter().GetResult();

try

{

// Loop over statements, skipping those that are already prepared (because they were persisted)

var isFirst = true;

foreach (var batchCommand in command.InternalBatchCommands)

{

if (!batchCommand.IsPreparing)

continue;

var pStatement = batchCommand.PreparedStatement!;

if (pStatement.StatementBeingReplaced != null)

{

Expect<CloseCompletedMessage>(await connector.ReadMessage(async).ConfigureAwait(false), connector);

pStatement.StatementBeingReplaced.CompleteUnprepare();

pStatement.StatementBeingReplaced = null;

}

Expect<ParseCompleteMessage>(await connector.ReadMessage(async).ConfigureAwait(false), connector);

Expect<ParameterDescriptionMessage>(await connector.ReadMessage(async).ConfigureAwait(false), connector);

var msg = await connector.ReadMessage(async).ConfigureAwait(false);

switch (msg.Code)

{

case BackendMessageCode.RowDescription:

// Clone the RowDescription for use with the prepared statement (the one we have is reused

// by the connection)

var description = ((RowDescriptionMessage)msg).Clone();

command.FixupRowDescription(description, isFirst);

batchCommand.Description = description;

break;

case BackendMessageCode.NoData:

batchCommand.Description = null;

break;

default:

throw connector.UnexpectedMessageReceived(msg.Code);

}

pStatement.State = PreparedState.Prepared;

connector.PreparedStatementManager.NumPrepared++;

batchCommand.IsPreparing = false;

isFirst = false;

}

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

}

finally

{

try

{

// Make sure sendTask is complete so we don't race against asynchronous flush

if (async)

await sendTask.ConfigureAwait(false);

else

sendTask.GetAwaiter().GetResult();

}

catch

{

// ignored

}

}

}

LogMessages.CommandPreparedExplicitly(connector.CommandLogger, connector.Id);

{

// The statements weren't prepared successfully, update the bookkeeping for them

foreach (var batchCommand in command.InternalBatchCommands)

{

if (batchCommand.IsPreparing)

{

batchCommand.IsPreparing = false;

batchCommand.PreparedStatement!.AbortPrepare();

}

}

throw;