{

_buffer = buffer;

_fieldStartPos = UninitializedSentinel;

_currentSize = UninitializedSentinel;

{

if (startPos > FieldOffset)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(startPos), "Can't revert forwardly");

_currentStartPos = startPos;

_currentBufferRequirement = bufferRequirement;

_currentSize = size;

{

if (NpgsqlReadBuffer.BufferBoundsChecks)

Core(count);

[MethodImpl(MethodImplOptions.NoInlining)]

void Core(int count)

{

if (count > CurrentRemaining)

ThrowHelper.ThrowIndexOutOfRangeException("Attempt to read past the end of the current field size.");

}

{

CheckBounds(sizeof(byte));

var result = _buffer.ReadByte();

return result;

{

CheckBounds(sizeof(short));

var result = _buffer.ReadInt16();

return result;

{

CheckBounds(sizeof(int));

var result = _buffer.ReadInt32();

return result;

{

CheckBounds(sizeof(long));

var result = _buffer.ReadInt64();

return result;

{

CheckBounds(sizeof(ushort));

var result = _buffer.ReadUInt16();

return result;

{

CheckBounds(sizeof(uint));

var result = _buffer.ReadUInt32();

return result;

{

CheckBounds(sizeof(ulong));

var result = _buffer.ReadUInt64();

return result;

{

CheckBounds(sizeof(float));

var result = _buffer.ReadSingle();

return result;

{

CheckBounds(sizeof(double));

var result = _buffer.ReadDouble();

return result;

{

CheckBounds(destination.Length);

_buffer.ReadBytes(destination);

{

var result = await _buffer.ReadNullTerminatedString(encoding, async: true, cancellationToken).ConfigureAwait(false);

// Can only check after the fact.

CheckBounds(0);

return result;

{

var result = _buffer.ReadNullTerminatedString(encoding, async: false, CancellationToken.None).GetAwaiter().GetResult();

CheckBounds(0);

return result;

{

if (length > CurrentRemaining)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(length), "Length is larger than the current remaining value size");

_requiresCleanup = true;

// This will cause any previously handed out StreamReaders etc to throw, as intended.

if (_userActiveStream is not null)

DisposeUserActiveStream(async: false).GetAwaiter().GetResult();

length ??= CurrentRemaining;

CheckBounds(length.GetValueOrDefault());

return _userActiveStream = _buffer.CreateStream(length.GetValueOrDefault(), canSeek && length <= _buffer.ReadBytesLeft, consumeOnDispose: false);

{

_requiresCleanup = true;

if (CurrentRemaining > _buffer.ReadBytesLeft || CurrentRemaining > MaxPreparedTextReaderSize)

return new StreamReader(GetColumnStream(), encoding, detectEncodingFromByteOrderMarks: false);

if (_preparedTextReader is { IsDisposed: false })

{

_preparedTextReader.Dispose();

_preparedTextReader = null;

}

_preparedTextReader ??= new PreparedTextReader();

_preparedTextReader.Init(

encoding.GetString(async

? await ReadBytesAsync(CurrentRemaining, cancellationToken).ConfigureAwait(false)

: ReadBytes(CurrentRemaining)), GetColumnStream(canSeek: false, 0));

return _preparedTextReader;

{

var count = buffer.Length;

CheckBounds(count);

var offset = _buffer.ReadPosition;

var remaining = _buffer.FilledBytes - offset;

if (remaining >= count)

{

_buffer.Buffer.AsSpan(offset, count).CopyTo(buffer.Span);

_buffer.ReadPosition += count;

return new();

}

return Slow(count, buffer, cancellationToken);

async ValueTask Slow(int count, Memory<byte> buffer, CancellationToken cancellationToken)

{

var stream = _buffer.CreateStream(count, canSeek: false);

await using var _ = stream.ConfigureAwait(false);

await stream.ReadExactlyAsync(buffer, cancellationToken).ConfigureAwait(false);

}

{

var count = buffer.Length;

CheckBounds(count);

var offset = _buffer.ReadPosition;

var remaining = _buffer.FilledBytes - offset;

if (remaining >= count)

{

_buffer.Buffer.AsSpan(offset, count).CopyTo(buffer);

_buffer.ReadPosition += count;

return;

}

Slow(count, buffer);

void Slow(int count, Span<byte> buffer)

{

using var stream = _buffer.CreateStream(count, canSeek: false);

stream.ReadExactly(buffer);

}

{

CheckBounds(count);

var offset = _buffer.ReadPosition;

var remaining = _buffer.FilledBytes - offset;

if (remaining >= count)

{

bytes = new ReadOnlySpan<byte>(_buffer.Buffer, offset, count);

_buffer.ReadPosition += count;

return true;

}

bytes = default;

return false;

{

CheckBounds(count);

var offset = _buffer.ReadPosition;

var remaining = _buffer.FilledBytes - offset;

if (remaining >= count)

{

bytes = new ReadOnlyMemory<byte>(_buffer.Buffer, offset, count);

_buffer.ReadPosition += count;

return true;

}

bytes = default;

return false;

{

CheckBounds(count);

var offset = _buffer.ReadPosition;

var remaining = _buffer.FilledBytes - offset;

if (remaining >= count)

{

var result = new ReadOnlySequence<byte>(_buffer.Buffer, offset, count);

_buffer.ReadPosition += count;

return result;

}

var array = RentArray(count);

ReadBytes(array.AsSpan(0, count));

return new(array, 0, count);

{

CheckBounds(count);

var offset = _buffer.ReadPosition;

var remaining = _buffer.FilledBytes - offset;

if (remaining >= count)

{

var result = new ReadOnlySequence<byte>(_buffer.Buffer, offset, count);

_buffer.ReadPosition += count;

return result;

}

var array = RentArray(count);

await ReadBytesAsync(array.AsMemory(0, count), cancellationToken).ConfigureAwait(false);

return new(array, 0, count);

{

if (CurrentOffset < count)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(count), "Attempt to rewind past the current field start.");

if (_buffer.ReadPosition < count)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(count), "Attempt to rewind past the buffer start, some of this data is no longer part of the underlying buffer.");

// Shut down any streaming going on on the column

if (StreamActive)

DisposeUserActiveStream(async: false).GetAwaiter().GetResult();

RewindCore(count);

{

Debug.Assert(CurrentOffset >= count);

Debug.Assert(_buffer.ReadPosition >= count);

_buffer.ReadPosition -= count;

{

if (async)

await (_userActiveStream?.DisposeAsync() ?? new()).ConfigureAwait(false);

else

_userActiveStream?.Dispose();

_userActiveStream = null;

{

if (!CharsReadActive)

ThrowHelper.ThrowInvalidOperationException("No active chars read");

charsRead = _charsRead;

reader = _charsReadReader ??= GetTextReader(encoding);

charsOffset = _charsReadOffset ?? 0;

buffer = _charsReadBuffer;

{

if (!CharsReadActive)

ThrowHelper.ThrowInvalidOperationException("No active chars read");

switch (_charsReadReader)

{

case PreparedTextReader reader:

reader.Restart();

break;

case StreamReader reader:

reader.BaseStream.Seek(0, SeekOrigin.Begin);

reader.DiscardBufferedData();

break;

}

_charsRead = 0;

{

if (!Resumable)

ThrowHelper.ThrowInvalidOperationException("Reader was not initialized as resumable");

_charsReadOffset = dataOffset;

_charsReadBuffer = buffer;

{

if (!Resumable)

ThrowHelper.ThrowInvalidOperationException("Wasn't initialized as resumed");

if (!CharsReadActive)

ThrowHelper.ThrowInvalidOperationException("No active chars read");

_charsReadOffset = null;

_charsReadBuffer = null;

{

if (Initialized)

ThrowHelper.ThrowInvalidOperationException("Already initialized");

_fieldStartPos = _buffer.CumulativeReadPosition;

_fieldConsumed = false;

_fieldSize = fieldSize;

_fieldFormat = fieldFormat;

_resumable = resumable;

{

Debug.Assert(FieldSize >= 0);

_fieldBufferRequirement = bufferRequirement;

var byteCount = BufferRequirements.GetMinimumBufferByteCount(bufferRequirement, FieldSize);

if (ShouldBuffer(byteCount))

BufferNoInlined(byteCount);

[MethodImpl(MethodImplOptions.NoInlining)]

void BufferNoInlined(int byteCount)

=> Buffer(byteCount);

{

Debug.Assert(FieldSize >= 0);

_fieldBufferRequirement = bufferRequirement;

var byteCount = BufferRequirements.GetMinimumBufferByteCount(bufferRequirement, FieldSize);

return ShouldBuffer(byteCount) ? BufferAsync(byteCount, cancellationToken) : new();

{

if (_resumable || StreamActive)

return;

// If it was upper bound we should consume.

if (_fieldBufferRequirement is { Kind: SizeKind.UpperBound })

{

Consume(FieldRemaining);

return;

}

if (FieldOffset != FieldSize)

ThrowNotConsumedExactly();

_fieldConsumed = true;

{

if (_resumable || StreamActive)

return new();

// If it was upper bound we should consume.

if (_fieldBufferRequirement is { Kind: SizeKind.UpperBound })

return ConsumeAsync(FieldRemaining);

if (FieldOffset != FieldSize)

ThrowNotConsumedExactly();

_fieldConsumed = true;

return new();

{

if (size > CurrentRemaining)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(size), "Cannot begin a read for a larger size than the current remaining size.");

if (size < 0)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(size), "Cannot be negative");

var previousSize = CurrentSize;

var previousStartPos = _currentStartPos;

var previousBufferRequirement = CurrentBufferRequirement;

_currentSize = size;

_currentBufferRequirement = bufferRequirement;

_currentStartPos = FieldOffset;

var byteCount = BufferRequirements.GetMinimumBufferByteCount(bufferRequirement, size);

if (ShouldBuffer(byteCount))

await Buffer(async, byteCount, cancellationToken).ConfigureAwait(false);

return new NestedReadScope(async, this, previousSize, previousStartPos, previousBufferRequirement);

{

var currentOffset = CurrentOffset;

if (currentOffset > offset)

Rewind(currentOffset - offset);

else if (currentOffset < offset)

Consume(offset - currentOffset);

{

if (count <= 0 || FieldSize < 0 || FieldRemaining == 0)

return;

var currentRemaining = CurrentRemaining;

var remaining = count ?? currentRemaining;

if (count > currentRemaining)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(count), "Attempt to read past the end of the current field size.");

if (StreamActive)

DisposeUserActiveStream(async: false).GetAwaiter().GetResult();

var origOffset = FieldOffset;

// A breaking exception unwind from a nested scope should not try to consume its remaining data.

if (!_buffer.Connector.IsBroken)

_buffer.Skip(remaining, allowIO: true);

Debug.Assert(FieldRemaining == FieldSize - origOffset - remaining);

{

if (count <= 0 || FieldSize < 0 || FieldRemaining == 0)

return;

var currentRemaining = CurrentRemaining;

var remaining = count ?? currentRemaining;

if (count > currentRemaining)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(count), "Attempt to read past the end of the current field size.");

if (StreamActive)

await DisposeUserActiveStream(async: true).ConfigureAwait(false);

var origOffset = FieldOffset;

// A breaking exception unwind from a nested scope should not try to consume its remaining data.

if (!_buffer.Connector.IsBroken)

await _buffer.Skip(async:true, remaining).ConfigureAwait(false);

Debug.Assert(FieldRemaining == FieldSize - origOffset - remaining);

{

if (StreamActive)

ThrowHelper.ThrowInvalidOperationException("A stream is already open for this reader");

{

if (StreamActive)

DisposeUserActiveStream(async: false).GetAwaiter().GetResult();

if (_pooledArray is not null)

{

ArrayPool.Return(_pooledArray);

_pooledArray = null;

}

if (_charsReadReader is not null)

{

_charsReadReader.Dispose();

_charsReadReader = null;

_charsRead = default;

}

_requiresCleanup = false;

{

_currentStartPos = 0;

_currentBufferRequirement = default;

_currentSize = UninitializedSentinel;

{

if (!Initialized)

ThrowHelper.ThrowInvalidOperationException("Cannot restart a non-initialized reader.");

// We resume if the reader was initialized as resumable and we're not explicitly restarting as non-resumable.

// When the field size is DbNullSentinel (i.e. -1) we're always restarting as resumable, to allow rereading null values endlessly.

var fieldSize = FieldSize;

if ((Resumable && resumable) || fieldSize is DbNullSentinel)

{

_resumable = true;

return fieldSize;

}

// From this point on we're not resuming, we're resetting any remaining state and rewinding our position.

// Shut down any streaming and pooling going on on the column.

if (_requiresCleanup)

Cleanup();

if (NestedInitialized)

ResetCurrent();

_fieldConsumed = false;

_resumable = resumable;

RewindCore(FieldOffset);

Debug.Assert(Initialized);

return fieldSize;

{

if (!Initialized)

return;

// Shut down any streaming and pooling going on on the column.

if (_requiresCleanup)

Cleanup();

if (NestedInitialized)

ResetCurrent();

// We make sure to fuly consume any FieldRemaining in the event of an exception or a nested scope not being disposed.

Debug.Assert(!NestedInitialized);

if (!_fieldConsumed && FieldRemaining > 0)

Consume();

_fieldStartPos = UninitializedSentinel;

Debug.Assert(!Initialized);

// These will always be re-initialized by Init()

// _fieldSize = default;

// _fieldFormat = default;

// _resumable = default;

// _fieldConsumed = default;

{

if (!Initialized)

return new();

// Shut down any streaming and pooling going on on the column.

if (_requiresCleanup)

Cleanup();

if (NestedInitialized)

ResetCurrent();

// We make sure to fuly consume any FieldRemaining in the event of an exception or a nested scope not being disposed.

Debug.Assert(!NestedInitialized);

if (!_fieldConsumed && FieldRemaining > 0)

return CommitAsync();

_fieldStartPos = UninitializedSentinel;

Debug.Assert(!Initialized);

// These will always be re-initialized by Init()

// _fieldSize = default;

// _fieldFormat = default;

// _resumable = default;

// _fieldConsumed = default;

return new();

async ValueTask CommitAsync()

{

await ConsumeAsync().ConfigureAwait(false);

_fieldStartPos = UninitializedSentinel;

Debug.Assert(!Initialized);

// These will always be re-initialized by Init()

// _fieldSize = default;

// _fieldFormat = default;

// _resumable = default;

// _fieldConsumed = default;

}

{

_requiresCleanup = true;

var pooledArray = _pooledArray;

if (pooledArray is not null)

{

if (pooledArray.Length >= count)

return pooledArray;

ArrayPool.Return(pooledArray);

}

var array = _pooledArray = ArrayPool.Rent(count);

return array;

{

return _buffer.ReadBytesLeft < byteCount && ShouldBufferSlow(byteCount);

[MethodImpl(MethodImplOptions.NoInlining)]

bool ShouldBufferSlow(int byteCount)

{

if (byteCount > _buffer.Size)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(byteCount),

"Buffer requirement is larger than the buffer size, this can never succeed by buffering data but requires a larger buffer size instead.");

if (byteCount > CurrentRemaining)

ThrowHelper.ThrowArgumentOutOfRangeException(nameof(byteCount),

"Buffer requirement is larger than the remaining length of the value, make sure the value is always at least this size or use an upper bound requirement instead.");

return true;

}

{

if (async)

return BufferAsync(byteCount, cancellationToken);

Buffer(byteCount);

return new();

}

void ThrowNotConsumedExactly() =>

throw _buffer.Connector.Break(

new InvalidOperationException(

FieldOffset < FieldSize

? $"The read on this field has not consumed all of its bytes (pos: {FieldOffset}, len: {FieldSize})"

: $"The read on this field has consumed all of its bytes and read into the subsequent bytes (pos: {FieldOffset}, len: {FieldSize})"));

readonly PgReader _reader;

readonly int _previousSize;

readonly int _previousStartPos;

readonly Size _previousBufferRequirement;

readonly bool _async;

internal NestedReadScope(bool async, PgReader reader, int previousSize, int previousStartPos, Size previousBufferRequirement)

{

_async = async;

_reader = reader;

_previousSize = previousSize;

_previousStartPos = previousStartPos;

_previousBufferRequirement = previousBufferRequirement;

}

public void Dispose()

{

if (_async)

ThrowHelper.ThrowInvalidOperationException("Cannot synchronously dispose async scopes, call DisposeAsync instead.");

DisposeAsync().GetAwaiter().GetResult();

}

public ValueTask DisposeAsync()

{

if (_reader.CurrentRemaining > 0)

{

if (_async)

return AsyncCore(_reader, _previousSize, _previousStartPos, _previousBufferRequirement);

_reader.Consume();

}

_reader.Revert(_previousSize, _previousStartPos, _previousBufferRequirement);

return new();

static async ValueTask AsyncCore(PgReader reader, int previousSize, int previousStartPos, Size previousBufferRequirement)

{

await reader.ConsumeAsync().ConfigureAwait(false);

reader.Revert(previousSize, previousStartPos, previousBufferRequirement);

}

}