#region License

// The PostgreSQL License

//

// Copyright (C) 2015 The Npgsql Development Team

//

// Permission to use, copy, modify, and distribute this software and its

// documentation for any purpose, without fee, and without a written

// agreement is hereby granted, provided that the above copyright notice

// and this paragraph and the following two paragraphs appear in all copies.

//

// IN NO EVENT SHALL THE NPGSQL DEVELOPMENT TEAM BE LIABLE TO ANY PARTY

// FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,

// INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS

// DOCUMENTATION, EVEN IF THE NPGSQL DEVELOPMENT TEAM HAS BEEN ADVISED OF

// THE POSSIBILITY OF SUCH DAMAGE.

//

// THE NPGSQL DEVELOPMENT TEAM SPECIFICALLY DISCLAIMS ANY WARRANTIES,

// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY

// AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS

// ON AN "AS IS" BASIS, AND THE NPGSQL DEVELOPMENT TEAM HAS NO OBLIGATIONS

// TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

#endregion

using System;

using System.Collections;

using System.Collections.Generic;

using System.Data;

using System.Data.Common;

using System.Diagnostics.Contracts;

using System.IO;

using System.Linq;

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Threading;

using System.Threading.Tasks;

using AsyncRewriter;

using JetBrains.Annotations;

using Npgsql.BackendMessages;

using Npgsql.TypeHandlers;

using Npgsql.TypeHandlers.NumericHandlers;

using NpgsqlTypes;

namespace Npgsql

{

/// <summary>

/// Reads a forward-only stream of rows from a data source.

/// </summary>

public partial class NpgsqlDataReader : DbDataReader

{

internal NpgsqlCommand Command { get; }

readonly NpgsqlConnector _connector;

readonly NpgsqlConnection _connection;

readonly CommandBehavior _behavior;

ReaderState State { get; set; }

/// <summary>

/// Holds the list of statements being executed by this reader.

/// </summary>

readonly List<NpgsqlStatement> _statements;

/// <summary>

/// The index of the current query resultset we're processing (within a multiquery)

/// </summary>

int _statementIndex;

/// <summary>

/// The RowDescription message for the current resultset being processed

/// </summary>

RowDescriptionMessage _rowDescription;

DataRowMessage _row;

uint? _recordsAffected;

/// <summary>

/// Indicates that at least one row has been read across all result sets

/// </summary>

bool _readOneRow;

/// <summary>

/// Whether the current result set has rows

/// </summary>

bool? _hasRows;

/// <summary>

/// If HasRows was called before any rows were read, it was forced to read messages. A pending

/// message may be stored here for processing in the next Read() or NextResult().

/// </summary>

IBackendMessage _pendingMessage;

#if NET45 || NET451 || DNX451

/// <summary>

/// If <see cref="GetSchemaTable"/> has been called, its results are cached here.

/// </summary>

DataTable _cachedSchemaTable;

#endif

/// <summary>

/// Is raised whenever Close() is called.

/// </summary>

public event EventHandler ReaderClosed;

/// <summary>

/// In non-sequential mode, contains the cached values already read from the current row

/// </summary>

readonly RowCache _rowCache;

// static readonly NpgsqlLogger Log = NpgsqlLogManager.GetCurrentClassLogger();

bool IsSequential => (_behavior & CommandBehavior.SequentialAccess) != 0;

bool IsCaching => !IsSequential;

bool IsSchemaOnly => (_behavior & CommandBehavior.SchemaOnly) != 0;

internal NpgsqlDataReader(NpgsqlCommand command, CommandBehavior behavior, List<NpgsqlStatement> statements)

{

Command = command;

_connection = command.Connection;

_connector = _connection.Connector;

_behavior = behavior;

State = IsSchemaOnly ? ReaderState.BetweenResults : ReaderState.InResult;

if (IsCaching) {

_rowCache = new RowCache();

}

_statements = statements;

}

[RewriteAsync]

internal void Init()

{

_rowDescription = _statements[0].Description;

if (_rowDescription == null)

{

// This happens if the first (or only) statement does not return a resultset (e.g. INSERT).

// At the end of Init the reader should be positioned at the beginning of the first resultset,

// so we seek it here.

if (!NextResult())

{

// No resultsets at all

return;

}

}

// If we have any output parameters, we need to read the first data row (in non-sequential mode)

// and extract them

if (Command.Parameters.Any(p => p.IsOutputDirection))

{

PopulateOutputParameters();

}

else

{

// If the query generated an error, we want an exception thrown here (i.e. from ExecuteQuery).

// So read the first message

// Note this isn't necessary if we're in SchemaOnly mode (we don't execute the query so no error

// is possible). Also, if we have output parameters as we already read the first message above.

if (!IsSchemaOnly)

{

_pendingMessage = ReadMessage();

}

}

}

/// <summary>

/// The first row in a stored procedure command that has output parameters needs to be traversed twice -

/// once for populating the output parameters and once for the actual result set traversal. So in this

/// case we can't be sequential.

/// </summary>

void PopulateOutputParameters()

{

Contract.Requires(_rowDescription != null);

Contract.Requires(Command.Parameters.Any(p => p.IsOutputDirection));

while (_row == null)

{

var msg = _connector.ReadSingleMessage(DataRowLoadingMode.NonSequential);

switch (msg.Code)

{

case BackendMessageCode.DataRow:

_pendingMessage = msg;

_row = (DataRowNonSequentialMessage)msg;

break;

case BackendMessageCode.CompletedResponse:

case BackendMessageCode.EmptyQueryResponse:

_pendingMessage = msg;

return;

default:

throw new ArgumentOutOfRangeException("Unexpected message type while populating output parameter: " + msg.Code);

}

}

Contract.Assume(_rowDescription.NumFields == _row.NumColumns);

if (IsCaching) { _rowCache.Clear(); }

var pending = new Queue<NpgsqlParameter>();

var taken = new List<int>();

foreach (var p in Command.Parameters.Where(p => p.IsOutputDirection))

{

int idx;

if (_rowDescription.TryGetFieldIndex(p.CleanName, out idx))

{

// TODO: Provider-specific check?

p.Value = GetValue(idx);

taken.Add(idx);

}

else

{

pending.Enqueue(p);

}

}

for (var i = 0; pending.Count != 0 && i != _row.NumColumns; ++i)

{

if (!taken.Contains(i))

{

// TODO: Need to get the provider-specific value based on the out param's type

pending.Dequeue().Value = GetValue(i);

}

}

}

#region Read

/// <summary>

/// Advances the reader to the next record in a result set.

/// </summary>

/// <returns><b>true</b> if there are more rows; otherwise <b>false</b>.</returns>

/// <remarks>

/// The default position of a data reader is before the first record. Therefore, you must call Read to begin accessing data.

/// </remarks>

public override bool Read()

{

return ReadInternal();

}

/// <summary>

/// This is the asynchronous version of <see cref="Read"/> The cancellation token is currently ignored.

/// </summary>

/// <param name="cancellationToken">Ignored for now.</param>

/// <returns>A task representing the asynchronous operation.</returns>

public override async Task<bool> ReadAsync(CancellationToken cancellationToken)

{

return await ReadInternalAsync(cancellationToken).ConfigureAwait(false);

}

[RewriteAsync]

bool ReadInternal()

{

if (_row != null) {

_row.Consume();

_row = null;

}

switch (State)

{

case ReaderState.InResult:

break;

case ReaderState.BetweenResults:

case ReaderState.Consumed:

case ReaderState.Closed:

return false;

default:

throw new ArgumentOutOfRangeException();

}

try

{

if ((_behavior & CommandBehavior.SingleRow) != 0 && _readOneRow)

{

// TODO: See optimization proposal in #410

Consume();

return false;

}

while (true)

{

var msg = ReadMessage();

switch (ProcessMessage(msg))

{

case ReadResult.RowRead:

return true;

case ReadResult.RowNotRead:

return false;

case ReadResult.ReadAgain:

continue;

default:

throw new ArgumentOutOfRangeException();

}

}

}

catch (NpgsqlException)

{

State = ReaderState.Consumed;

throw;

}

}

ReadResult ProcessMessage(IBackendMessage msg)

{

Contract.Requires(msg != null);

switch (msg.Code)

{

case BackendMessageCode.DataRow:

Contract.Assert(_rowDescription != null);

_connector.State = ConnectorState.Fetching;

_row = (DataRowMessage)msg;

Contract.Assume(_rowDescription.NumFields == _row.NumColumns);

if (IsCaching) { _rowCache.Clear(); }

_readOneRow = true;

_hasRows = true;

return ReadResult.RowRead;

case BackendMessageCode.CompletedResponse:

var completed = (CommandCompleteMessage) msg;

switch (completed.StatementType)

{

case StatementType.Update:

case StatementType.Insert:

case StatementType.Delete:

case StatementType.Copy:

if (!_recordsAffected.HasValue) {

_recordsAffected = 0;

}

_recordsAffected += completed.Rows;

break;

}

_statements[_statementIndex].StatementType = completed.StatementType;

_statements[_statementIndex].Rows = completed.Rows;

_statements[_statementIndex].OID = completed.OID;

goto case BackendMessageCode.EmptyQueryResponse;

case BackendMessageCode.EmptyQueryResponse:

State = ReaderState.BetweenResults;

return ReadResult.RowNotRead;

case BackendMessageCode.ReadyForQuery:

State = ReaderState.Consumed;

return ReadResult.RowNotRead;

case BackendMessageCode.BindComplete:

case BackendMessageCode.CloseComplete:

return ReadResult.ReadAgain;

default:

throw new Exception("Received unexpected backend message of type " + msg.Code);

}

}

#endregion

#region NextResult

/// <summary>

/// Advances the reader to the next result when reading the results of a batch of statements.

/// </summary>

/// <returns></returns>

public override sealed bool NextResult()

{

return IsSchemaOnly ? NextResultSchemaOnly() : NextResultInternal();

}

/// <summary>

/// This is the asynchronous version of NextResult.

/// The <paramref name="cancellationToken"/> parameter is currently ignored.

/// </summary>

/// <param name="cancellationToken">Currently ignored.</param>

/// <returns>A task representing the asynchronous operation.</returns>

public override async sealed Task<bool> NextResultAsync(CancellationToken cancellationToken)

{

return IsSchemaOnly ? NextResultSchemaOnly() : await NextResultInternalAsync(cancellationToken).ConfigureAwait(false);

}

[RewriteAsync]

bool NextResultInternal()

{

Contract.Requires(!IsSchemaOnly);

// Contract.Ensures(Command.CommandType != CommandType.StoredProcedure || Contract.Result<bool>() == false);

try

{

// If we're in the middle of a resultset, consume it

switch (State)

{

case ReaderState.InResult:

if (_row != null) {

_row.Consume();

_row = null;

}

// TODO: Duplication with SingleResult handling above

var completedMsg = SkipUntil(BackendMessageCode.CompletedResponse, BackendMessageCode.EmptyQueryResponse);

ProcessMessage(completedMsg);

break;

case ReaderState.BetweenResults:

break;

case ReaderState.Consumed:

case ReaderState.Closed:

return false;

default:

throw new ArgumentOutOfRangeException();

}

Contract.Assert(State == ReaderState.BetweenResults);

_hasRows = null;

#if NET45 || NET451 || DNX451

_cachedSchemaTable = null;

#endif

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

{

if (State == ReaderState.BetweenResults) {

Consume();

}

return false;

}

// We are now at the end of the previous result set. Read up to the next result set, if any.

for (_statementIndex++; _statementIndex < _statements.Count; _statementIndex++)

{

_rowDescription = _statements[_statementIndex].Description;

if (_rowDescription != null)

{

State = ReaderState.InResult;

// Found a resultset

return true;

}

// Next query has no resultset, read and process its completion message and move on to the next

var completedMsg = SkipUntil(BackendMessageCode.CompletedResponse, BackendMessageCode.EmptyQueryResponse);

ProcessMessage(completedMsg);

}

// There are no more queries, we're done. Read to the RFQ.

ProcessMessage(SkipUntil(BackendMessageCode.ReadyForQuery));

_rowDescription = null;

return false;

}

catch (NpgsqlException)

{

State = ReaderState.Consumed;

throw;

}

}

/// <summary>

/// Note that in SchemaOnly mode there are no resultsets, and we read nothing from the backend (all

/// RowDescriptions have already been processed and are available)

/// </summary>

bool NextResultSchemaOnly()

{

Contract.Requires(IsSchemaOnly);

for (_statementIndex++; _statementIndex < _statements.Count; _statementIndex++)

{

_rowDescription = _statements[_statementIndex].Description;

if (_rowDescription != null)

{

// Found a resultset

return true;

}

}

return false;

}

#endregion

[RewriteAsync]

IBackendMessage ReadMessage()

{

if (_pendingMessage != null) {

var msg = _pendingMessage;

_pendingMessage = null;

return msg;

}

return _connector.ReadSingleMessage(IsSequential ? DataRowLoadingMode.Sequential : DataRowLoadingMode.NonSequential);

}

[RewriteAsync]

IBackendMessage SkipUntil(BackendMessageCode stopAt)

{

if (_pendingMessage != null)

{

if (_pendingMessage.Code == stopAt)

{

var msg = _pendingMessage;

_pendingMessage = null;

return msg;

}

_pendingMessage = null;

}

return _connector.SkipUntil(stopAt);

}

[RewriteAsync]

IBackendMessage SkipUntil(BackendMessageCode stopAt1, BackendMessageCode stopAt2)

{

if (_pendingMessage != null) {

if (_pendingMessage.Code == stopAt1 || _pendingMessage.Code == stopAt2) {

var msg = _pendingMessage;

_pendingMessage = null;

return msg;

}

_pendingMessage = null;

}

return _connector.SkipUntil(stopAt1, stopAt2);

}

/// <summary>

/// Gets a value indicating the depth of nesting for the current row. Always returns zero.

/// </summary>

public override Int32 Depth => 0;

/// <summary>

/// Gets a value indicating whether the data reader is closed.

/// </summary>

public override bool IsClosed => State == ReaderState.Closed;

/// <summary>

/// Gets the number of rows changed, inserted, or deleted by execution of the SQL statement.

/// </summary>

public override int RecordsAffected => _recordsAffected.HasValue ? (int)_recordsAffected.Value : -1;

/// <summary>

/// Returns details about each statement that this reader will or has executed.

/// </summary>

/// <remarks>

/// Note that some fields (i.e. rows and oid) are only populated as the reader

/// traverses the result.

///

/// For commands with multiple queries, this exposes the number of rows affected on

/// a statement-by-statement basis, unlike <see cref="NpgsqlDataReader.RecordsAffected"/>

/// which exposes an aggregation across all statements.

/// </remarks>

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

/// <summary>

/// Gets a value that indicates whether this DbDataReader contains one or more rows.

/// </summary>

public override bool HasRows

{

get

{

if (_hasRows.HasValue) {

return _hasRows.Value;

}

if (_statementIndex >= _statements.Count) {

return false;

}

while (true)

{

var msg = ReadMessage();

switch (msg.Code)

{

case BackendMessageCode.BindComplete:

case BackendMessageCode.RowDescription:

ProcessMessage(msg);

continue;

case BackendMessageCode.DataRow:

_pendingMessage = msg;

_hasRows = true;

return true;

case BackendMessageCode.CompletedResponse:

case BackendMessageCode.EmptyQueryResponse:

_pendingMessage = msg;

_hasRows = false;

return false;

case BackendMessageCode.CloseComplete:

_hasRows = false;

return false;

default:

throw new ArgumentOutOfRangeException("Got unexpected message type: " + msg.Code);

}

}

}

}

/// <summary>

/// Indicates whether the reader is currently positioned on a row, i.e. whether reading a

/// column is possible.

/// This property is different from <see cref="HasRows"/> in that <see cref="HasRows"/> will

/// return true even if attempting to read a column will fail, e.g. before <see cref="Read"/>

/// has been called

/// </summary>

[PublicAPI]

public bool IsOnRow => _row != null;

/// <summary>

/// Gets the name of the column, given the zero-based column ordinal.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The name of the specified column.</returns>

public override string GetName(int ordinal)

{

CheckResultSet();

CheckOrdinal(ordinal);

Contract.EndContractBlock();

return _rowDescription[ordinal].Name;

}

/// <summary>

/// Gets the number of columns in the current row.

/// </summary>

public override int FieldCount => _rowDescription?.NumFields ?? 0;

#region Cleanup / Dispose

/// <summary>

/// Consumes all result sets for this reader, leaving the connector ready for sending and processing further

/// queries

/// </summary>

[RewriteAsync]

void Consume()

{

if (IsSchemaOnly)

{

State = ReaderState.Consumed;

return;

}

if (_row != null)

{

_row.Consume();

_row = null;

}

// Skip over the other result sets, processing only CommandCompleted for RecordsAffected

while (true)

{

var msg = SkipUntil(BackendMessageCode.CompletedResponse, BackendMessageCode.ReadyForQuery);

switch (msg.Code)

{

case BackendMessageCode.CompletedResponse:

ProcessMessage(msg);

continue;

case BackendMessageCode.ReadyForQuery:

ProcessMessage(msg);

return;

default:

throw new Exception("Unexpected message of type " + msg.Code);

}

}

}

/// <summary>

/// Releases the resources used by the <see cref="NpgsqlDataReader">NpgsqlDataReader</see>.

/// </summary>

protected override void Dispose(bool disposing)

{

Close();

}

/// <summary>

/// Closes the <see cref="NpgsqlDataReader"/> object.

/// </summary>

#if NET45 || NET451 || DNX451

public override void Close()

#else

public void Close()

#endif

{

if (State == ReaderState.Closed) { return; }

switch (_connector.State)

{

case ConnectorState.Broken:

case ConnectorState.Closed:

// This may have happen because an I/O error while reading a value, or some non-safe

// exception thrown from a type handler. Or if the connection was closed while the reader

// was still open

State = ReaderState.Closed;

Command.State = CommandState.Idle;

ReaderClosed?.Invoke(this, EventArgs.Empty);

return;

}

if (State != ReaderState.Consumed) {

Consume();

}

Cleanup();

}

internal void Cleanup()

{

State = ReaderState.Closed;

Command.State = CommandState.Idle;

_connector.CurrentReader = null;

_connector.EndUserAction();

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

{

_connection.Close();

}

if (ReaderClosed != null)

{

ReaderClosed(this, EventArgs.Empty);

ReaderClosed = null;

}

}

#endregion

/// <summary>

/// Returns the current row, or throws an exception if a row isn't available

/// </summary>

private DataRowMessage Row

{

get

{

if (_row == null) {

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

}

return _row;

}

}

#region Simple value getters

/// <summary>

/// Gets the value of the specified column as a Boolean.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override bool GetBoolean(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumnWithoutCache<bool>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a byte.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override byte GetByte(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumnWithoutCache<byte>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a single character.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override char GetChar(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumnWithoutCache<char>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a 16-bit signed integer.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override short GetInt16(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<short>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a 32-bit signed integer.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override int GetInt32(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<int>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a 64-bit signed integer.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override long GetInt64(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<long>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a <see cref="DateTime"/> object.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override DateTime GetDateTime(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<DateTime>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as an instance of <see cref="string"/>.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override string GetString(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<string>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a <see cref="decimal"/> object.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override decimal GetDecimal(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<decimal>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a double-precision floating point number.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override double GetDouble(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<double>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a single-precision floating point number.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override float GetFloat(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<float>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a globally-unique identifier (GUID).

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override Guid GetGuid(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<Guid>(ordinal);

}

/// <summary>

/// Populates an array of objects with the column values of the current row.

/// </summary>

/// <param name="values">An array of Object into which to copy the attribute columns.</param>

/// <returns>The number of instances of <see cref="object"/> in the array.</returns>

public override int GetValues(object[] values)

{

#region Contracts

if (values == null)

throw new ArgumentNullException(nameof(values));

CheckRow();

Contract.Ensures(Contract.Result<int>() >= 0 && Contract.Result<int>() <= values.Length);

#endregion

var count = Math.Min(FieldCount, values.Length);

for (var i = 0; i < count; i++) {

values[i] = GetValue(i);

}

return count;

}

/// <summary>

/// Gets the value of the specified column as an instance of <see cref="object"/>.

/// </summary>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public override object this[int ordinal]

{

get

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return GetValue(ordinal);

}

}

#endregion

#region Provider-specific type getters

/// <summary>

/// Gets the value of the specified column as an <see cref="NpgsqlDate"/>,

/// Npgsql's provider-specific type for dates.

/// </summary>

/// <remarks>

/// PostgreSQL's date type represents dates from 4713 BC to 5874897 AD, while .NET's DateTime

/// only supports years from 1 to 1999. If you require years outside this range use this accessor.

/// The standard <see cref="GetProviderSpecificValue"/> method will also return this type, but has

/// the disadvantage of boxing the value.

/// See http://www.postgresql.org/docs/current/static/datatype-datetime.html

/// </remarks>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public NpgsqlDate GetDate(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<NpgsqlDate>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as a TimeSpan,

/// </summary>

/// <remarks>

/// PostgreSQL's interval type has has a resolution of 1 microsecond and ranges from

/// -178000000 to 178000000 years, while .NET's TimeSpan has a resolution of 100 nanoseconds

/// and ranges from roughly -29247 to 29247 years.

/// See http://www.postgresql.org/docs/current/static/datatype-datetime.html

/// </remarks>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public TimeSpan GetTimeSpan(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<TimeSpan>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as an <see cref="NpgsqlTimeSpan"/>,

/// Npgsql's provider-specific type for time spans.

/// </summary>

/// <remarks>

/// PostgreSQL's interval type has has a resolution of 1 microsecond and ranges from

/// -178000000 to 178000000 years, while .NET's TimeSpan has a resolution of 100 nanoseconds

/// and ranges from roughly -29247 to 29247 years. If you require values from outside TimeSpan's

/// range use this accessor.

/// The standard ADO.NET <see cref="GetProviderSpecificValue"/> method will also return this

/// type, but has the disadvantage of boxing the value.

/// See http://www.postgresql.org/docs/current/static/datatype-datetime.html

/// </remarks>

/// <param name="ordinal">The zero-based column ordinal.</param>

/// <returns>The value of the specified column.</returns>

public NpgsqlTimeSpan GetInterval(int ordinal)

{

CheckRowAndOrdinal(ordinal);

Contract.EndContractBlock();

return ReadColumn<NpgsqlTimeSpan>(ordinal);

}

/// <summary>

/// Gets the value of the specified column as an <see cref="NpgsqlDateTime"/>,

/// Npgsql's provider-specific type for date/time timestamps. Note that this type covers

/// both PostgreSQL's "timestamp with time zone" and "timestamp without time zone" types,

/// which differ only in how they are converted upon input/output.

/// </summary>

/// <remarks>

/// PostgreSQL's timestamp type represents dates from 4713 BC to 5874897 AD, while .NET's DateTime

/// only supports years from 1 to 1999. If you require years outside this range use this accessor.

/// The standard <see cref="GetProviderSpecificValue"/> method will also return this type, but has

/// the disadvantage of boxing the value.

/// See http://www.postgresql.org/docs/current/static/datatype-datetime.html

/// </remarks>

/// <param name="ordinal">The zero-based column ordinal.</param>