{

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

}

}

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

{

// Do not quote strings, or escape existing quotes - this will be handled by the backend.

// DBNull or null values are returned as null.

// TODO: Would it be better to remove this null special handling out of ConvertToBackend??

// Do special handling of bytea values. They will be send in binary form.

// TODO: Add binary format support for all supported types. Not only bytea.

if (parameters[i].TypeInfo.NpgsqlDbType != NpgsqlDbType.Bytea)

{

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

}

else

{

if (parameters[i].Value != DBNull.Value)

{

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

parameterValues[i] = (byte[])parameters[i].Value;

}

else

{

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

}

}

}

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 && returnRowDescData.TypeInfo.NpgsqlDbType == NpgsqlDbType.Bytea)

{

// Binary format

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

}

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;

{

bool inTextLiteral = false;

int endAt = array.Length - 1;//leave last char for separate append as we don't have to continually check we're safe to add the next char too.

for(int i = 0; i != endAt; ++i)

{

if(array[i] == '\'')

{

if(!inTextLiteral)

{

query.Append("E'");

inTextLiteral = true;

}

else if(array[i + 1] == '\'')//SQL-escaped '

{

query.Append("''");

++i;

}

else

{

query.Append('\'');

inTextLiteral = false;

}

}

else

query.Append(array[i]);

}

query.Append(array[endAt]);

{

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

// 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.Append('(');

if(Connector.UseConformantStrings)

switch(serialised[0])

{

case '\''://type passed as string or string with type.

//We could test to see if \ is used anywhere, but then we could be doing quite an expensive check (if the value is large) for little gain.

query.Append("E").Append(serialised);

break;

case 'a':

if(POSTGRES_TEXT_ARRAY.IsMatch(serialised))

PassEscapedArray(query, serialised);

else

query.Append(serialised);

break;

default:

query.Append(serialised);

break;

}

else

query.Append(serialised);

query.Append(')');

if (p.UseCast)

{

query.Append("::").Append(p.TypeInfo.CastName);

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

query.Append('(').Append(p.Size).Append(')');

}

{

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;