{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, CLASSNAME);

planName = String.Empty;

text = cmdText;

this.connection = connection;

if (this.connection != null)

{

this.m_Connector = connection.Connector;

}

type = CommandType.Text;

this.Transaction = transaction;

SetCommandTimeout();

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, CLASSNAME);

planName = String.Empty;

text = cmdText;

this.m_Connector = connector;

type = CommandType.Text;

// Removed this setting. It was causing too much problem.

// Do internal commands really need different timeout setting?

// Internal commands aren't affected by command timeout value provided by user.

// timeout = 20;

{

get { return text; }

set

{

// [TODO] Validate commandtext.

NpgsqlEventLog.LogPropertySet(LogLevel.Debug, CLASSNAME, "CommandText", value);

text = value;

planName = String.Empty;

parse = null;

bind = null;

functionChecksDone = false;

}

{

get { return timeout; }

set

{

if (value < 0)

{

throw new ArgumentOutOfRangeException(resman.GetString("Exception_CommandTimeoutLessZero"));

}

timeout = value;

NpgsqlEventLog.LogPropertySet(LogLevel.Debug, CLASSNAME, "CommandTimeout", value);

commandTimeoutSet = true;

}

{

get { return type; }

set

{

type = value;

NpgsqlEventLog.LogPropertySet(LogLevel.Debug, CLASSNAME, "CommandType", value);

}

{

get { return Connection; }

set

{

Connection = (NpgsqlConnection)value;

NpgsqlEventLog.LogPropertySet(LogLevel.Debug, CLASSNAME, "DbConnection", value);

}

{

get

{

NpgsqlEventLog.LogPropertyGet(LogLevel.Debug, CLASSNAME, "Connection");

return connection;

}

set

{

if (this.Connection == value)

{

return;

}

//if (this.transaction != null && this.transaction.Connection == null)

// this.transaction = null;

// All this checking needs revising. It should be simpler.

// This this.Connector != null check was added to remove the nullreferenceexception in case

// of the previous connection has been closed which makes Connector null and so the last check would fail.

// See bug 1000581 for more details.

if (this.transaction != null && this.connection != null && this.Connector != null && this.Connector.Transaction != null)

{

throw new InvalidOperationException(resman.GetString("Exception_SetConnectionInTransaction"));

}

this.connection = value;

Transaction = null;

if (this.connection != null)

{

m_Connector = this.connection.Connector;

}

SetCommandTimeout();

NpgsqlEventLog.LogPropertySet(LogLevel.Debug, CLASSNAME, "Connection", value);

}

{

get

{

if (this.connection != null)

{

m_Connector = this.connection.Connector;

}

return m_Connector;

}

{

get

{

NpgsqlEventLog.LogPropertyGet(LogLevel.Debug, CLASSNAME, "Parameters");

return parameters;

}

{

get { return Transaction; }

set

{

Transaction = (NpgsqlTransaction)value;

NpgsqlEventLog.LogPropertySet(LogLevel.Debug, CLASSNAME, "IDbCommand.Transaction", value);

}

{

get

{

NpgsqlEventLog.LogPropertyGet(LogLevel.Debug, CLASSNAME, "Transaction");

if (this.transaction != null && this.transaction.Connection == null)

{

this.transaction = null;

}

return this.transaction;

}

set

{

NpgsqlEventLog.LogPropertySet(LogLevel.Debug, CLASSNAME, "Transaction", value);

this.transaction = value;

}

{

get

{

NpgsqlEventLog.LogPropertyGet(LogLevel.Debug, CLASSNAME, "UpdatedRowSource");

return 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();

}

}

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "Cancel");

try

{

// get copy for thread safety of null test

NpgsqlConnector connector = Connector;

if (connector != null)

{

connector.CancelRequest();

}

}

catch (IOException)

{

Connection.ClearPool();

}

catch (NpgsqlException)

{

// Cancel documentation says the Cancel doesn't throw on failure

}

{

// TODO: Add consistency checks.

NpgsqlCommand clone = new NpgsqlCommand(CommandText, Connection, Transaction);

clone.CommandTimeout = CommandTimeout;

clone.CommandType = CommandType;

clone.DesignTimeVisible = DesignTimeVisible;

if (ExpectedTypes != null)

{

clone.ExpectedTypes = (Type[])ExpectedTypes.Clone();

}

foreach (NpgsqlParameter parameter in Parameters)

{

clone.Parameters.Add(parameter.Clone());

}

return clone;

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "CreateDbParameter");

return CreateParameter();

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "CreateParameter");

return new NpgsqlParameter();

{

//We treat this as a simple wrapper for calling ExecuteReader() and then

//update the records affected count at every call to NextResult();

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "ExecuteNonQuery");

int? ret = null;

using (NpgsqlDataReader rdr = GetReader(CommandBehavior.SequentialAccess))

{

do

{

int thisRecord = rdr.RecordsAffected;

if (thisRecord != -1)

{

ret = (ret ?? 0) + thisRecord;

}

lastInsertedOID = rdr.LastInsertedOID ?? lastInsertedOID;

}

while (rdr.NextResult());

}

return ret ?? -1;

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "ExecuteReader");

return ExecuteReader(CommandBehavior.Default);

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "ExecuteReader", cb);

// Close connection if requested even when there is an error.

try

{

if (connection != null)

{

if (connection.PreloadReader)

{

//Adjust behaviour so source reader is sequential access - for speed - and doesn't close the connection - or it'll do so at the wrong time.

CommandBehavior adjusted = (cb | CommandBehavior.SequentialAccess) & ~CommandBehavior.CloseConnection;

return new CachingDataReader(GetReader(adjusted), cb);

}

}

return GetReader(cb);

}

catch (Exception)

{

if ((cb & CommandBehavior.CloseConnection) == CommandBehavior.CloseConnection)

{

connection.Close();

}

throw;

}

{

try

{

CheckConnectionState();

// reset any responses just before getting new ones

Connector.Mediator.ResetResponses();

// Set command timeout.

m_Connector.Mediator.CommandTimeout = CommandTimeout;

using (m_Connector.BlockNotificationThread())

{

ForwardsOnlyDataReader reader;

if (parse == null)

{

reader = new ForwardsOnlyDataReader(m_Connector.QueryEnum(this), cb, this,

m_Connector.BlockNotificationThread(), false);

if (type == CommandType.StoredProcedure

&& reader.FieldCount == 1

&& reader.GetDataTypeName(0) == "refcursor")

{

// When a function returns a sole column of refcursor, transparently

// FETCH ALL from every such cursor and return those results.

StringBuilder sb = new StringBuilder();

while (reader.Read())

{

sb.Append("fetch all from \"").Append(reader.GetString(0)).Append("\";");

}

sb.Append(";"); // Just in case the list of cursors is empty.

//reader = new NpgsqlCommand(sb.ToString(), Connection).GetReader(reader._behavior);

// Passthrough the commandtimeout to the inner command, so user can also control its timeout.

// TODO: Check if there is a better way to handle that.

NpgsqlCommand c = new NpgsqlCommand(sb.ToString(), Connection);

c.CommandTimeout = this.CommandTimeout;

reader = c.GetReader(reader._behavior);

}

}

else

{

BindParameters();

reader = new ForwardsOnlyDataReader(m_Connector.ExecuteEnum(new NpgsqlExecute(bind.PortalName, 0)), cb, this,

m_Connector.BlockNotificationThread(), true);

}

return reader;

}

}

catch (IOException ex)

{

throw ClearPoolAndCreateException(ex);

}

{

if (parameters.Count != 0)

{

Object[] parameterValues = new Object[parameters.Count];

Int16[] parameterFormatCodes = bind.ParameterFormatCodes;

for (Int32 i = 0; i < parameters.Count; i++)

{

parameterValues[i] = parameters[i].TypeInfo.ConvertToBackend(parameters[i].Value, true, Connector.NativeToBackendTypeConverterOptions);

if (parameterValues[i] == null) {

parameterFormatCodes[i]= (Int16)FormatCode.Binary;

} else {

parameterFormatCodes[i] = parameterValues[i].GetType() == typeof(byte[]) ? (Int16)FormatCode.Binary : (Int16)FormatCode.Text;

}

}

bind.ParameterValues = parameterValues;

bind.ParameterFormatCodes = parameterFormatCodes;

}

try

{

// In case of error when binding parameters, the ReadyForQuery isn't returned.

// According to docs: "[...] The response is either BindComplete or ErrorResponse."

Connector.RequireReadyForQuery = false;

Connector.Bind(bind);

Connector.Flush();

}

catch

{

// Check catch{} of Preapre method for discussion about that.

Connector.Sync();

throw;

}

{

using (

NpgsqlDataReader reader =

GetReader(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult | CommandBehavior.SingleRow))

{

return reader.Read() && reader.FieldCount != 0 ? reader.GetValue(0) : null;

}

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "Prepare");

// Check the connection state.

CheckConnectionState();

// reset any responses just before getting new ones

Connector.Mediator.ResetResponses();

// Set command timeout.

m_Connector.Mediator.CommandTimeout = CommandTimeout;

if (!m_Connector.SupportsPrepare)

{

return; // Do nothing.

}

if (m_Connector.BackendProtocolVersion == ProtocolVersion.Version2)

{

using (NpgsqlCommand command = new NpgsqlCommand(GetPrepareCommandText(), m_Connector))

{

command.ExecuteBlind();

}

}

else

{

using (m_Connector.BlockNotificationThread())

{

try

{

// Use the extended query parsing...

planName = m_Connector.NextPlanName();

String portalName = m_Connector.NextPortalName();

parse = new NpgsqlParse(planName, GetParseCommandText(), new Int32[] { });

m_Connector.Parse(parse);

// We need that because Flush() doesn't cause backend to send

// ReadyForQuery on error. Without ReadyForQuery, we don't return

// from query extended processing.

// We could have used Connector.Flush() which sends us back a

// ReadyForQuery, but on postgresql server below 8.1 there is an error

// with extended query processing which hinders us from using it.

m_Connector.RequireReadyForQuery = false;

m_Connector.Flush();

// Description...

NpgsqlDescribe describe = new NpgsqlDescribe('S', planName);

m_Connector.Describe(describe);

NpgsqlRowDescription returnRowDesc = m_Connector.Sync();

Int16[] resultFormatCodes;

if (returnRowDesc != null)

{

resultFormatCodes = new Int16[returnRowDesc.NumFields];

for (int i = 0; i < returnRowDesc.NumFields; i++)

{

NpgsqlRowDescription.FieldData returnRowDescData = returnRowDesc[i];

if (returnRowDescData.TypeInfo != null)

{

// Binary format?

resultFormatCodes[i] = returnRowDescData.TypeInfo.SupportsBinaryBackendData ? (Int16)FormatCode.Binary : (Int16)FormatCode.Text;

}

else

{

// Text Format

resultFormatCodes[i] = (Int16)FormatCode.Text;

}

}

}

else

{

resultFormatCodes = new Int16[] { 0 };

}

bind = new NpgsqlBind("", planName, new Int16[Parameters.Count], null, resultFormatCodes);

}

catch (IOException e)

{

throw ClearPoolAndCreateException(e);

}

catch

{

// As per documentation:

// "[...] When an error is detected while processing any extended-query message,

// the backend issues ErrorResponse, then reads and discards messages until a

// Sync is reached, then issues ReadyForQuery and returns to normal message processing.[...]"

// So, send a sync command if we get any problems.

m_Connector.Sync();

throw;

}

}

}

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "CheckConnectionState");

// Check the connection state.

if (Connector == null || Connector.State == ConnectionState.Closed)

{

throw new InvalidOperationException(resman.GetString("Exception_ConnectionNotOpen"));

}

if (Connector.State != ConnectionState.Open)

{

throw new InvalidOperationException(

"There is already an open DataReader associated with this Command which must be closed first.");

}

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "GetCommandText");

StringBuilder ret = string.IsNullOrEmpty(planName) ? GetClearCommandText() : GetPreparedCommandText();

// In constructing the command text, we potentially called internal

// queries. Reset command timeout and SQL sent.

m_Connector.Mediator.ResetResponses();

m_Connector.Mediator.CommandTimeout = CommandTimeout;

return ret;

{

string serialised = (string)p.TypeInfo.ConvertToBackend(p.Value, false, Connector.NativeToBackendTypeConverterOptions);

// Add parentheses wrapping parameter value before the type cast to avoid problems with Int16.MinValue, Int32.MinValue and Int64.MinValue

// See bug #1010543

// Check if this parenthesis can be collapsed with the previous one about the array support. This way, we could use

// only one pair of parentheses for the two purposes instead of two pairs.

query.AppendFormat("({0})", serialised);

if (p.UseCast)

{

query.AppendFormat("::{0}", p.TypeInfo.CastName);

if (p.TypeInfo.UseSize && (p.Size > 0))

{

query.AppendFormat("({0})", p.Size);

}

}

{

if (NpgsqlEventLog.Level == LogLevel.Debug)

{

NpgsqlEventLog.LogMethodEnter(LogLevel.Debug, CLASSNAME, "GetClearCommandText");

}

StringBuilder result = PGUtil.TrimStringBuilder(new StringBuilder(text));

switch(type)

{

case CommandType.TableDirect:

return result.Insert(0, "select * from "); // There is no parameter support on table direct.

case CommandType.StoredProcedure:

if (!functionChecksDone)

{

functionNeedsColumnListDefinition = Parameters.Count != 0 && CheckFunctionNeedsColumnDefinitionList();

// Check if just procedure name was passed. If so, does not replace parameter names and just pass parameter values in order they were added in parameters collection. Also check if command text finishes in a ";" which would make Npgsql incorrectly append a "()" when executing this command text.

switch(result[result.Length - 1])

{

case ')' : case ';':

addProcedureParenthesis = false;

break;

default:

addProcedureParenthesis = true;

break;

}

functionChecksDone = true;

}

result.Insert(0,

Connector.SupportsPrepare

? "select * from " // This syntax is only available in 7.3+ as well SupportsPrepare.

: "select " //Only a single result return supported. 7.2 and earlier.

);

break;

}

if (parameters.Count == 0)

{

if (addProcedureParenthesis)

result.Append("()");

if (functionNeedsColumnListDefinition)

AddFunctionColumnListSupport(result);

return result;

}

// Get parameters in query string to translate them to their actual values.

// This regular expression gets all the parameters in format :param or @param

// and everythingelse.

// This is only needed if query string has parameters. Else, just append the

// parameter values in order they were put in parameter collection.

// If parenthesis don't need to be added, they were added by user with parameter names. Replace them.

if (!addProcedureParenthesis)

{

Dictionary<string, NpgsqlParameter> parameterIndex = new Dictionary<string, NpgsqlParameter>(parameters.Count, StringComparer.InvariantCultureIgnoreCase);

foreach (NpgsqlParameter parameter in parameters)

parameterIndex[parameter.CleanName] = parameter;

StringBuilder sb = new StringBuilder();

foreach (String s in parameterReplace.Split(result.ToString()))

if (s.Length != 0)

{

NpgsqlParameter p = null;

string parameterName = s;

if ((parameterName[0] == ':') || (parameterName[0] == '@'))

{

parameterName = parameterName.Remove(0, 1);

parameterIndex.TryGetValue(parameterName, out p);

}

if (p != null)

{

switch(p.Direction)

{

case ParameterDirection.Input: case ParameterDirection.InputOutput:

//Wrap in probably-redundant parentheses. Queries should operate much as if they were in the a parameter or

//variable in a postgres function. Generally this is the case without the parentheses (hence "probably redundant")