NpgsqlConnector.NotificationThreadBlock threadBlock,

bool preparedStatement = false, NpgsqlRowDescription rowDescription = null)

{

_behavior = behavior;

_connector = command.Connector;

Command = command;

_connection = command.Connection;

command.Connector.CurrentReader = this;

_threadBlock = threadBlock;

_preparedStatement = preparedStatement;

CurrentDescription = rowDescription;

{

if (CurrentDescription != null)

{

IEnumerable<NpgsqlParameter> inputOutputAndOutputParams = Command.Parameters.Cast<NpgsqlParameter>()

.Where(p => p.Direction == ParameterDirection.InputOutput || p.Direction == ParameterDirection.Output);

if (!inputOutputAndOutputParams.Any())

{

return;

}

NpgsqlRow row = ParameterUpdateRow;

if (row == null)

{

return;

}

Queue<NpgsqlParameter> pending = new Queue<NpgsqlParameter>();

List<int> taken = new List<int>();

foreach (NpgsqlParameter p in inputOutputAndOutputParams)

{

int idx = CurrentDescription.TryFieldIndex(p.CleanName);

if (idx == -1)

{

pending.Enqueue(p);

}

else

{

p.Value = row.Get(idx);

taken.Add(idx);

}

}

for (int i = 0; pending.Count != 0 && i != row.NumFields; ++i)

{

if (!taken.Contains(i))

{

pending.Dequeue().Value = row.Get(i);

}

}

}

{

if (fo == null)

{

return null;

}

else

{

fo.SetRowDescription(CurrentDescription);

if ((_behavior & CommandBehavior.SequentialAccess) == CommandBehavior.SequentialAccess)

{

return fo;

}

else

{

return new CachingRow(fo);

}

}

{

get

{

NpgsqlRow ret = CurrentRow ?? _pendingRow ?? GetNextRow(false);

if (ret is ForwardsOnlyRow)

{

ret = _pendingRow = new CachingRow((ForwardsOnlyRow) ret);

}

return ret;

}

{

get { return _currentRow; }

set

{

if (_currentRow != null)

{

_currentRow.Dispose();

}

_currentRow = value;

}

{

if (CurrentRow == null)

{

throw new InvalidOperationException("Invalid attempt to read when no data is present.");

}

#endif

{

cancellationToken.ThrowIfCancellationRequested();

// TODO: What is the desired behavior when cancelling here?

// cancellationToken.Register(...)

return ReadInternalAsync();

{

try

{

//CurrentRow = null;

return (CurrentRow = GetNextRow(true)) != null;

}

catch (IOException)

{

Command.Connection.ClearPool();

throw;

}

{

get

{

// Return true even after the last row has been read in this result.

// the first call to GetNextRow will set _hasRows to true if rows are found.

return _hasRows || (GetNextRow(false) != null);

}

{

if (_pendingDescription != null)

{

return null;

}

if (((_behavior & CommandBehavior.SingleRow) != 0 && CurrentRow != null && _pendingDescription == null) ||

((_behavior & CommandBehavior.SchemaOnly) != 0))

{

if (!clearPending)

{

return null;

}

//We should only have one row, and we've already had it. Move to end

//of recordset.

CurrentRow = null;

for (object skip = GetNextServerMessage();

skip != null && (_pendingDescription = skip as NpgsqlRowDescription) == null;

skip = GetNextServerMessage())

{

if (skip is NpgsqlRow)

{

(skip as NpgsqlRow).Dispose();

}

}

return null;

}

if (_pendingRow != null)

{

NpgsqlRow ret = _pendingRow;

if (clearPending)

{

_pendingRow = null;

}

if (!_hasRows)

{

// when rows are found, store that this result has rows.

_hasRows = (ret != null);

}

return ret;

}

CurrentRow = null;

object objNext = GetNextServerMessage();

if (clearPending)

{

_pendingRow = null;

}

if (objNext is NpgsqlRowDescription)

{

_pendingDescription = objNext as NpgsqlRowDescription;

return null;

}

if (!_hasRows)

{

// when rows are found, store that this result has rows.

_hasRows = objNext is NpgsqlRow;

}

return objNext as NpgsqlRow;

{

if (_preparedStatement) {

// Prepared statements can never have multiple results.

return false;

}

return NextResultInternal();

#endif

{

cancellationToken.ThrowIfCancellationRequested();

// TODO: What is the desired behavior when cancelling here?

// cancellationToken.Register(...)

if (_preparedStatement) {

// Prepared statements can never have multiple results.

return PGUtil.TaskFromResult(false);

}

return NextResultInternalAsync();

{

try

{

CurrentRow = null;

_currentResultsetSchema = null;

_hasRows = false; // set to false and let the reading code determine if the set has rows.

return (CurrentDescription = GetNextRowDescription()) != null;

}

catch (IOException)

{

Command.Connection.ClearPool();

throw;

}

{

if (_cleanedUp)

return null;

try

{

CurrentRow = null;

if (_pendingRow != null)

{

_pendingRow.Dispose();

}

_pendingRow = null;

while (true)

{

var msg = _connector.ReadMessage();

if (msg is RowReader)

{

RowReader reader = msg as RowReader;

if (cleanup)

{

// V3 rows can dispose by simply reading MessageLength bytes.

reader.Dispose();

return reader;

}

else

{

return _pendingRow = BuildRow(new ForwardsOnlyRow(reader));

}

}

else if (msg is CompletedResponse)

{

CompletedResponse cr = msg as CompletedResponse;

if (cr.RowsAffected.HasValue)

{

_nextRecordsAffected = (_nextRecordsAffected ?? 0) + cr.RowsAffected.Value;

}

_nextInsertOID = cr.LastInsertedOID ?? _nextInsertOID;

}

// TODO: The check for the three COPY protocol messages slow down our normal

// processing. Simply separate the flow (don't use ExecuteNonQuery)

else if (msg is ReadyForQueryMsg ||

msg is CopyInResponseMsg || msg is CopyOutResponseMsg || msg is CopyDataMsg)

{

CleanUp(true);

return null;

}

else

{

return msg;

}

}

}

catch

{

CleanUp(true);

throw;

}

{

if ((_behavior & CommandBehavior.SingleResult) != 0 && CurrentDescription != null)

{

CleanUp(false);

return null;

}

NpgsqlRowDescription rd = _pendingDescription;

while (rd == null)

{

object objNext = GetNextServerMessage();

if (objNext == null)

{

break;

}

if (objNext is NpgsqlRow)

{

(objNext as NpgsqlRow).Dispose();

}

rd = objNext as NpgsqlRowDescription;

}

_pendingDescription = null;

// If there were records affected before, keep track of their values.

if (_recordsAffected != null)

_recordsAffected += (_nextRecordsAffected ?? 0);

else

_recordsAffected = _nextRecordsAffected;

_nextRecordsAffected = null;

LastInsertedOID = _nextInsertOID;

_nextInsertOID = null;

return rd;

{

lock (this)

{

if (_cleanedUp) {

return;

}

if (!finishedMessages)

{

do

{

if ((Thread.CurrentThread.ThreadState & (ThreadState.Aborted | ThreadState.AbortRequested)) != 0)

{

_connection.EmergencyClose();

return;

}

}

while (GetNextServerMessage(true) != null);

}

_cleanedUp = true;

}

_threadBlock.Dispose();

{

CleanUp(false);

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

{

_connection.Close();

}

_isClosed = true;

if (ReaderClosed != null) {

ReaderClosed(this, EventArgs.Empty);

}

#endif

{

return (T)await GetValueInternalAsync(ordinal);

{

object providerValue = GetProviderSpecificValue(ordinal);

NpgsqlBackendTypeInfo backendTypeInfo;

if (Command.ExpectedTypes != null && Command.ExpectedTypes.Length > ordinal && Command.ExpectedTypes[ordinal] != null)

{

return ExpectedTypeConverter.ChangeType(providerValue, Command.ExpectedTypes[ordinal]);

}

else if ((_connection == null || !_connection.UseExtendedTypes) && TryGetTypeInfo(ordinal, out backendTypeInfo))

return backendTypeInfo.ConvertToFrameworkType(providerValue);

return providerValue;

{

if (ordinal < 0 || ordinal >= CurrentDescription.NumFields)

{

throw new IndexOutOfRangeException("Column index out of range");

}

CheckHaveRow();

return CurrentRow.Get(ordinal);

{

// Should this be done using the GetValue directly and not by converting to String

// and parsing from there?

return (Boolean)GetValueInternal(i);

{

//This is an interesting one. In the world of databases we've the idea of chars which is 0 to n characters

//where n is stated (and can perhaps be infinite) and various variations upon that (postgres is admirable

//in being relatively consistent and in not generally encouraging limiting n purely for performance reasons,

//but across many different platforms we'll find such things as text, ntext, char, nchar, varchar, nvarchar,

//and so on with some platforms not having them all and many implementaiton differences).

//

//In the world of .NET, and many other languages, we have the idea of characters and of strings - which are

//sequences of characters with differing degress of encapsulation from C just having char* through to .NET

//having full-blown objects

//

//Database char, varchar, text, etc. are all generally mapped to strings. There's a bit of a question as to

//what maps to a .NET char. Interestingly enough, SQLDataReader doesn't support GetChar() and neither do

//a few other providers (Oracle for example). It would seem that IDataReader.GetChar() was defined largely

//to have a complete set of .NET base types. Still, the closest thing in the database world to a char value

//is a char(1) or varchar(1) - that is to say the value of a string of length one, so that's what is used here.

//

//In case of the type is "char", we can return the .NET Char directly.

Object value = GetValueInternal(i);

if (value is Char)

{

return (Char)value;

}

String s = (String)value;

if (s.Length != 1)

{

throw new InvalidCastException();

}

return s[0];

{

object ret = GetValueInternal(i);

if (ret is bool)

return new BitString((bool)ret);

else

return (BitString)ret;

{

CheckHaveRow();

return CurrentRow.IsDBNull(ordinal);

#endif

{

CheckHaveRow();

return CurrentRow.IsDBNullAsync(ordinal);

{

CheckHaveRow();

// Only the number of elements in the array are filled.

// It's also possible to pass an array with more that FieldCount elements.

Int32 maxColumnIndex = (values.Length < FieldCount) ? values.Length : FieldCount;

for (Int32 i = 0; i < maxColumnIndex; i++)

{

values[i] = getValue(i);

}

return maxColumnIndex;

{

if (CurrentDescription == null)

{

throw new IndexOutOfRangeException(); //Essentially, all indices are out of range.

}

return CurrentDescription[Index].Name;

{

if (CurrentDescription == null)

{

throw new IndexOutOfRangeException(); //Essentially, all indices are out of range.

}

return CurrentDescription[Index].TypeOID.ToString();

{

if (CurrentDescription == null)