private IEnumerable <ResolvedEvent> read_log(string stream_name, ReadDirection read_direction, int buffer)
{
StreamEventsSlice currentSlice;
var nextSliceStart = read_direction == ReadDirection.Forward ? StreamPosition.Start : StreamPosition.End;
do
{
if (read_direction == ReadDirection.Forward)
{
currentSlice = connection
.ReadStreamEventsForwardAsync(stream_name, nextSliceStart, buffer, false)
.Result;
}
else
{
currentSlice = connection
.ReadStreamEventsBackwardAsync(stream_name, nextSliceStart, buffer, false)
.Result;
}
nextSliceStart = currentSlice.NextEventNumber;
foreach (var item in currentSlice.Events)
{
yield return(item);
}
} while (!currentSlice.IsEndOfStream);
}
internal StreamEventsSlice(SliceReadStatus status,
string stream,
int fromEventNumber,
ReadDirection readDirection,
ClientMessage.ResolvedIndexedEvent[] events,
int nextEventNumber,
int lastEventNumber,
bool isEndOfStream)
{
Ensure.NotNullOrEmpty(stream, "stream");
Status = status;
Stream = stream;
FromEventNumber = fromEventNumber;
ReadDirection = readDirection;
if (events == null || events.Length == 0)
{
Events = Empty.ResolvedEvents;
}
else
{
Events = new ResolvedEvent[events.Length];
for (int i = 0; i < Events.Length; ++i)
{
Events[i] = new ResolvedEvent(events[i]);
}
}
NextEventNumber = nextEventNumber;
LastEventNumber = lastEventNumber;
IsEndOfStream = isEndOfStream;
}
public void Read(string pageUri, ReadDirection direction, Func <string, string, Navigation, bool> pageWriter)
{
var relationshipType = direction == ReadDirection.Forward ? "next-archive" : "prev-archive";
var continueToNextPage = true;
while (continueToNextPage && !string.IsNullOrEmpty(pageUri))
{
var response = CallEndpointAndReturnResultForFullUrl(pageUri);
SyndicationFeed feed = SyndicationFeed.Load(new XmlTextReader(new StringReader(response.Content)));
Navigation pageNavigation = GetPageNavigation(feed);
continueToNextPage = pageWriter(pageUri, response.Content, pageNavigation);
if (continueToNextPage)
{
var lastPageUri = pageUri;
pageUri = feed?.Links.FirstOrDefault(li => li.RelationshipType == relationshipType)?.Uri.ToString();
if (string.IsNullOrEmpty(pageUri) &&
direction == ReadDirection.Forward &&
LatestPageUrl != lastPageUri)
{
pageUri = LatestPageUrl;
}
}
}
}
internal StreamEventsSlice(SliceReadStatus status,
string stream,
int fromEventNumber,
ReadDirection readDirection,
ClientMessage.ResolvedIndexedEvent[] events,
int nextEventNumber,
int lastEventNumber,
bool isEndOfStream)
{
Ensure.NotNullOrEmpty(stream, "stream");
Status = status;
Stream = stream;
FromEventNumber = fromEventNumber;
ReadDirection = readDirection;
if (events == null || events.Length == 0)
Events = Empty.ResolvedEvents;
else
{
Events = new ResolvedEvent[events.Length];
for (int i = 0; i < Events.Length; ++i)
{
Events[i] = new ResolvedEvent(events[i]);
}
}
NextEventNumber = nextEventNumber;
LastEventNumber = lastEventNumber;
IsEndOfStream = isEndOfStream;
}
public static MySqlParameter ReadDirection(ReadDirection readDirection)
=> new MySqlParameter
{
MySqlDbType = MySqlDbType.Bool,
Value = readDirection == Streams.ReadDirection.Forward,
ParameterName = "_forwards"
};
public Task<AllEventsPage> ReadAll(
Checkpoint checkpoint,
int maxCount,
ReadDirection direction = ReadDirection.Forward,
CancellationToken cancellationToken = default(CancellationToken))
{
return _inner.ReadAll(checkpoint, maxCount, direction, cancellationToken);
}
public Task<AllEventsPage> ReadAll(
Checkpoint checkpoint,
int maxCount,
ReadDirection direction = ReadDirection.Forward,
CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
public static NpgsqlParameter ReadDirection(ReadDirection direction)
{
return(new NpgsqlParameter <bool>
{
NpgsqlDbType = NpgsqlDbType.Boolean,
TypedValue = direction == Streams.ReadDirection.Forward
});
}
private StreamEventsSlice ReadFromStream(
string streamName,
long start,
long count,
List <RecordedEvent> stream,
ReadDirection direction)
{
var result = new List <RecordedEvent>();
var next = start == -1 ? stream.Count - 1 : (int)start;
for (int i = 0; i < count; i++)
{
if (next < stream.Count && next >= 0)
{
long current = next;
result.Add(stream[(int)current]);
}
next += (int)direction;
}
bool isEnd;
if (direction == ReadDirection.Forward)
{
isEnd = next >= stream.Count;
if (next > stream.Count)
{
next = stream.Count;
}
}
else //Direction.Backward
{
isEnd = next < 0;
if (next < 0)
{
next = StreamPosition.End;
}
if (next > stream.Count + 1)
{
next = stream.Count - 1;
}
else if (next > stream.Count)
{
next = stream.Count;
}
}
var slice = new StreamEventsSlice(
streamName,
start,
direction,
result.ToArray(),
next,
stream.Count - 1,
isEnd);
return(slice);
}
/// <summary>
/// Reads the stream.
/// </summary>
/// <param name="streamId">The stream identifier.</param>
/// <param name="start">The start.</param>
/// <param name="count">The count.</param>
/// <param name="direction">The direction.</param>
/// <returns></returns>
public Task <StreamEventsPage> ReadStream(
string streamId,
int start,
int count,
ReadDirection direction = ReadDirection.Forward,
CancellationToken cancellationToken = default(CancellationToken))
{
return(direction == ReadDirection.Forward
? ReadSteamForwards(streamId, start, count)
: ReadSteamBackwards(streamId, start, count));
}
private CosmosStream(string id, string type, Version version, StreamReadStatus streamReadStatus,
ReadDirection readDirection, CosmosEvent[] events)
{
Id = id;
Type = type;
Version = version;
StreamReadStatus = streamReadStatus;
ReadDirection = readDirection;
Events = events;
LastEventNumber = Events.Length;
NextEventNumber = LastEventNumber + 1;
}
public AllEventsPage(
long fromCheckpoint,
long nextCheckpoint,
bool isEnd,
ReadDirection direction,
params StreamEvent[] streamEvents)
{
FromCheckpoint = fromCheckpoint;
NextCheckpoint = nextCheckpoint;
IsEnd = isEnd;
Direction = direction;
StreamEvents = streamEvents;
}
public AllMessagesPage(
long fromPosition,
long nextPosition,
bool isEnd,
ReadDirection direction,
params StreamMessage[] messages)
{
FromPosition = fromPosition;
NextPosition = nextPosition;
IsEnd = isEnd;
Direction = direction;
Messages = messages;
}
public async Task Empty_Streams_return_StreamNotFound(ReadDirection direction, int start, int pageSize)
{
using(var fixture = GetFixture())
{
using(var eventStore = await fixture.GetEventStore())
{
var streamEventsPage =
await eventStore.ReadStream("stream-does-not-exist", start, pageSize, direction);
streamEventsPage.Status.ShouldBe(PageReadStatus.StreamNotFound);
}
}
}
public ReadAllPage(
long fromPosition,
long nextPosition,
bool isEnd,
ReadDirection direction,
StreamMessage[] messages,
ReadNextAllPage readNext)
{
FromPosition = fromPosition;
NextPosition = nextPosition;
IsEnd = isEnd;
Direction = direction;
Messages = messages;
_readNext = readNext;
}
/// <summary>
/// Initializes a new instance of <see cref="ReadAllPage"/>
/// </summary>
/// <param name="fromPosition">A long representing the position where this page was read from.</param>
/// <param name="nextPosition">A long representing the position where the next page should be read from.</param>
/// <param name="isEnd">True if page reach end of the all stream at time of reading. Otherwise false.</param>
/// <param name="direction">The direction of the the read request.</param>
/// <param name="readNext">An operation to read the next page of messages.</param>
/// <param name="messages">The collection messages read.</param>
public ReadAllPage(
long fromPosition,
long nextPosition,
bool isEnd,
ReadDirection direction,
ReadNextAllPage readNext,
StreamMessage[] messages = null)
{
FromPosition = fromPosition;
NextPosition = nextPosition;
IsEnd = isEnd;
Direction = direction;
_readNext = readNext;
Messages = messages ?? new StreamMessage[0];
}
public Task <long?> AllStreamPosition(ReadDirection direction, Guid eventId)
{
using (var command = CreateCommand())
{
command.CommandText = @"SELECT messages.position
FROM messages
WHERE messages.stream_id_internal = (SELECT id_internal FROM streams WHERE id_original = @streamId)
AND messages.event_id = @eventId;";
command.Parameters.Clear();
command.Parameters.AddWithValue("@streamId", _streamId);
command.Parameters.AddWithValue("@eventId", eventId);
command.Parameters.AddWithValue("@forwards", direction == ReadDirection.Forward);
return(Task.FromResult(command.ExecuteScalar <long?>()));
}
}
public async Task Deleted_Streams_return_StreamDeleted(ReadDirection direction, int start, int pageSize)
{
using (var fixture = GetFixture())
{
using (var eventStore = await fixture.GetEventStore())
{
await eventStore.AppendToStream("stream-1", ExpectedVersion.NoStream, CreateNewStreamEvents(1, 2, 3));
await eventStore.DeleteStream("stream-1", ExpectedVersion.Any);
var streamEventsPage =
await eventStore.ReadStream("stream-1", start, pageSize, direction);
streamEventsPage.Status.ShouldBe(PageReadStatus.StreamDeleted);
}
}
}
internal AllEventsSlice(ReadDirection readDirection, Position fromPosition, Position nextPosition, ClientMessage.ResolvedEvent[] events)
{
ReadDirection = readDirection;
FromPosition = fromPosition;
NextPosition = nextPosition;
if (events == null)
Events = EmptyEvents;
else
{
Events = new ResolvedEvent[events.Length];
for (int i = 0; i < Events.Length; ++i)
{
Events[i] = new ResolvedEvent(events[i]);
}
}
}
internal AllEventsSlice(ReadDirection readDirection, Position fromPosition, Position nextPosition, ClientMessage.ResolvedEvent[] events)
{
ReadDirection = readDirection;
FromPosition = fromPosition;
NextPosition = nextPosition;
if (events == null)
{
Events = Empty.ResolvedEvents;
}
else
{
Events = new ResolvedEvent[events.Length];
for (int i = 0; i < Events.Length; ++i)
{
Events[i] = new ResolvedEvent(events[i]);
}
}
}
public Task <long?> Remaining(ReadDirection direction, long?index)
{
using (var command = CreateCommand())
{
// determine number of remaining messages.
command.CommandText = @"SELECT COUNT(*)
FROM messages
WHERE
CASE
WHEN @readForward THEN messages.[position] >= @position
ELSE messages.[position] <= @position
END;";
command.Parameters.Clear();
command.Parameters.AddWithValue("@position", index);
command.Parameters.AddWithValue("@readForward", direction == ReadDirection.Forward);
return(Task.FromResult <long?>(command.ExecuteScalar(Position.End)));
}
}
public Task <int> Length(ReadDirection direction, long?startingIndex, CancellationToken cancellationToken)
{
using (var command = CreateCommand())
{
command.CommandText = @"SELECT COUNT(*)
FROM messages
WHERE messages.stream_id_internal = (SELECT id_internal FROM streams WHERE id_original = @streamId LIMIT 1)
AND CASE
WHEN @forwards THEN messages.[position] >= @position
ELSE messages.[position] <= @position
END; -- count of remaining messages.";
command.Parameters.Clear();
command.Parameters.AddWithValue("@streamId", _streamId);
command.Parameters.AddWithValue("@position", startingIndex);
command.Parameters.AddWithValue("@forwards", direction == ReadDirection.Forward);
return(Task.FromResult(command.ExecuteScalar <int>()));
}
}
public StreamEventsPage(
string streamId,
PageReadStatus status,
int fromStreamVersion,
int nextStreamVersion,
int lastStreamVersion,
ReadDirection direction,
bool isEndOfStream,
params StreamEvent[] events)
{
StreamId = streamId;
Status = status;
FromStreamVersion = fromStreamVersion;
LastStreamVersion = lastStreamVersion;
NextStreamVersion = nextStreamVersion;
ReadDirection = direction;
IsEndOfStream = isEndOfStream;
Events = events;
}
public StreamEventsPage(
string streamId,
PageReadStatus status,
int fromStreamVersion,
int nextStreamVersion,
int lastStreamVersion,
ReadDirection direction,
bool isEndOfStream,
params StreamEvent[] events)
{
StreamId = streamId;
Status = status;
FromStreamVersion = fromStreamVersion;
LastStreamVersion = lastStreamVersion;
NextStreamVersion = nextStreamVersion;
ReadDirection = direction;
IsEndOfStream = isEndOfStream;
Events = events;
}
public StreamMessagesPage(
string streamId,
PageReadStatus status,
int fromStreamVersion,
int nextStreamVersion,
int lastStreamVersion,
ReadDirection direction,
bool isEndOfStream,
params StreamMessage[] messages)
{
StreamId = streamId;
Status = status;
FromStreamVersion = fromStreamVersion;
LastStreamVersion = lastStreamVersion;
NextStreamVersion = nextStreamVersion;
ReadDirection = direction;
IsEndOfStream = isEndOfStream;
Messages = messages;
}
private int GetPointerOffset(ReadDirection readDirection, int accessorId, int tileIndex)
{
int offSet = 0;
switch (readDirection)
{
case ReadDirection.LeftToRight:
offSet = (4 * accessorId) + tileIndex;
break;
case ReadDirection.RightToLeft:
offSet = (4 * accessorId) + (3 - tileIndex);
break;
case ReadDirection.TopDown:
offSet = (4 * tileIndex) + accessorId;
break;
case ReadDirection.BottomUp:
offSet = (4 * (3 - tileIndex)) + accessorId;
break;
}
return offSet;
}
public StreamEventsSlice(
string stream,
long fromEventNumber,
ReadDirection readDirection,
RecordedEvent[] events,
long nextEventNumber,
long lastEventNumber,
bool isEndOfStream)
{
if (string.IsNullOrWhiteSpace(stream))
{
throw new ArgumentNullException(nameof(stream), "Stream cannot be null, empty or whitespace");
}
Stream = stream;
FromEventNumber = fromEventNumber;
ReadDirection = readDirection;
Events = events ?? new RecordedEvent[0];
NextEventNumber = nextEventNumber;
LastEventNumber = lastEventNumber;
IsEndOfStream = isEndOfStream;
}
/// <summary>
/// Initialized a new instance of <see cref="ReadStreamPage"/>/
/// </summary>
/// <param name="streamId">The id of the stream that was read.</param>
/// <param name="status">The <see cref="PageReadStatus"/> of the read operation.</param>
/// <param name="fromStreamVersion">The version of the stream that read from.</param>
/// <param name="nextStreamVersion">The next message version that can be read.</param>
/// <param name="lastStreamVersion">The version of the last message in the stream.</param>
/// <param name="lastStreamPosition">The position of the last message in the stream.</param>
/// <param name="direction">The direction of the read operation.</param>
/// <param name="isEnd">Whether or not this is the end of the stream.</param>
/// <param name="readNext">An operation to read the next page.</param>
/// <param name="messages">The messages read.</param>
public ReadStreamPage(
string streamId,
PageReadStatus status,
int fromStreamVersion,
int nextStreamVersion,
int lastStreamVersion,
long lastStreamPosition,
ReadDirection direction,
bool isEnd,
ReadNextStreamPage readNext = null,
StreamMessage[] messages = null)
{
StreamId = streamId;
Status = status;
FromStreamVersion = fromStreamVersion;
LastStreamVersion = lastStreamVersion;
LastStreamPosition = lastStreamPosition;
NextStreamVersion = nextStreamVersion;
ReadDirection = direction;
IsEnd = isEnd;
Messages = messages ?? new StreamMessage[0];
_readNext = readNext ?? ((_, __) => throw new NotSupportedException());
}
public Task <long?> AllStreamPosition(ReadDirection direction, long?version)
{
using (var command = CreateCommand())
{
command.CommandText = @"SELECT messages.position
FROM messages
WHERE messages.stream_id_internal = (SELECT id_internal FROM streams WHERE id_original = @streamId)
AND messages.stream_version = @version;";
command.Parameters.Clear();
command.Parameters.AddWithValue("@streamId", _streamId);
command.Parameters.AddWithValue("@version", version);
command.Parameters.AddWithValue("@forwards", direction == ReadDirection.Forward);
var position = command.ExecuteScalar <long?>();
if (position == null)
{
command.CommandText = @"SELECT CASE
WHEN @forwards THEN MIN(messages.position)
ELSE MAX(messages.position)
END
FROM messages
WHERE messages.stream_id_internal = (SELECT id_internal FROM streams WHERE id_original = @streamId)
AND CASE
WHEN @forwards THEN messages.stream_version >= @version
ELSE messages.stream_version <= @version
END;";
command.Parameters.Clear();
command.Parameters.AddWithValue("@streamId", _streamId);
command.Parameters.AddWithValue("@version", version);
command.Parameters.AddWithValue("@forwards", direction == ReadDirection.Forward);
position = command.ExecuteScalar <long?>(long.MaxValue);
}
return(Task.FromResult(position));
}
}
public async Task<AllEventsPage> ReadAll(
Checkpoint checkpoint,
int maxCount,
ReadDirection direction = ReadDirection.Forward,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.That(checkpoint, "checkpoint").IsNotNull();
CheckIfDisposed();
var connection = _getConnection();
var position = checkpoint.ParsePosition();
AllEventsSlice allEventsSlice;
if(direction == ReadDirection.Forward)
{
allEventsSlice = await connection
.ReadAllEventsForwardAsync(position, maxCount, resolveLinkTos: false)
.NotOnCapturedContext();
}
else
{
allEventsSlice = await connection
.ReadAllEventsBackwardAsync(position, maxCount, resolveLinkTos: false)
.NotOnCapturedContext();
}
var events = allEventsSlice
.Events
.Where(@event =>
!(@event.OriginalEvent.EventType.StartsWith("$")
|| @event.OriginalStreamId.StartsWith("$")))
.Select(resolvedEvent => resolvedEvent.ToSteamEvent())
.ToArray();
return new AllEventsPage(
allEventsSlice.FromPosition.ToString(),
allEventsSlice.NextPosition.ToString(),
allEventsSlice.IsEndOfStream,
GetReadDirection(allEventsSlice.ReadDirection),
events);
}
public Task<StreamEventsPage> ReadStream(
string streamId,
int start,
int count,
ReadDirection direction = ReadDirection.Forward,
CancellationToken cancellationToken = default(CancellationToken))
{
return _inner.ReadStream(streamId, start, count, direction, cancellationToken);
}
/// <summary>
/// Reads the stream.
/// </summary>
/// <param name="streamId">The stream identifier.</param>
/// <param name="start">The start.</param>
/// <param name="count">The count.</param>
/// <param name="direction">The direction.</param>
/// <returns></returns>
public Task<StreamEventsPage> ReadStream(
string streamId,
int start,
int count,
ReadDirection direction = ReadDirection.Forward,
CancellationToken cancellationToken = default(CancellationToken))
{
return direction == ReadDirection.Forward
? ReadSteamForwards(streamId, start, count)
: ReadSteamBackwards(streamId, start, count);
}
public TileAccessor( int accessorId, ReadDirection readDirection, ref TilesBuffer buffer)
{
this._accessorId = accessorId;
this._readDirection = readDirection;
AttachToTiles(ref buffer);
}
private async Task <(ReadStreamPage, StreamMeta)> ReadStreamInternal(
SqlStreamId sqlStreamId,
int start,
int count,
ReadDirection direction,
bool prefetch,
ReadNextStreamPage readNext,
SqlConnection connection,
SqlTransaction transaction,
CancellationToken cancellationToken)
{
// If the count is int.MaxValue, TSql will see it as a negative number.
// Users shouldn't be using int.MaxValue in the first place anyway.
count = count == int.MaxValue ? count - 1 : count;
// To read backwards from end, need to use int MaxValue
var streamVersion = start == StreamVersion.End ? int.MaxValue : start;
string commandText;
Func <List <(StreamMessage, int?)>, int, int> getNextVersion;
if (direction == ReadDirection.Forward)
{
commandText = prefetch ? _scripts.ReadStreamForwardWithData : _scripts.ReadStreamForward;
getNextVersion = (events, lastVersion) =>
events.Any()
? events.Last().Item1.StreamVersion + 1
: lastVersion + 1;
}
else
{
commandText = prefetch ? _scripts.ReadStreamBackwardWithData : _scripts.ReadStreamBackward;
getNextVersion = (events, lastVersion) =>
events.Any()
? events.Last().Item1.StreamVersion - 1
: -1;
}
using (var command = new SqlCommand(commandText, connection, transaction))
{
command.Parameters.Add(new SqlParameter("streamId", SqlDbType.Char, 42)
{
Value = sqlStreamId.Id
});
command.Parameters.AddWithValue("count", count + 1); //Read extra row to see if at end or not
command.Parameters.AddWithValue("streamVersion", streamVersion);
using (var reader = await command.ExecuteReaderAsync(cancellationToken).NotOnCapturedContext())
{
await reader.ReadAsync(cancellationToken).NotOnCapturedContext();
if (reader.IsDBNull(0))
{
return(new ReadStreamPage(
sqlStreamId.IdOriginal,
PageReadStatus.StreamNotFound,
start,
-1,
-1,
-1,
direction,
true,
readNext),
StreamMeta.None);
}
var lastStreamVersion = reader.GetInt32(0);
var lastStreamPosition = reader.GetInt64(1);
var maxAge = reader.GetNullableInt32(2);
var maxCount = reader.GetNullableInt32(3);
await reader.NextResultAsync(cancellationToken).NotOnCapturedContext();
var messages = new List <(StreamMessage, int?)>();
while (await reader.ReadAsync(cancellationToken).NotOnCapturedContext())
{
if (messages.Count == count)
{
messages.Add(default);
public async Task<StreamEventsPage> ReadStream(
string streamId,
int start,
int count,
ReadDirection direction = ReadDirection.Forward,
CancellationToken cancellationToken = default(CancellationToken))
{
var connection = _getConnection();
StreamEventsSlice streamEventsSlice;
if (direction == ReadDirection.Forward)
{
streamEventsSlice = await connection
.ReadStreamEventsForwardAsync(streamId, start, count, true)
.NotOnCapturedContext();
}
else
{
streamEventsSlice = await connection
.ReadStreamEventsBackwardAsync(streamId, start, count, true)
.NotOnCapturedContext();
}
return new StreamEventsPage(
streamId,
(PageReadStatus)Enum.Parse(typeof(PageReadStatus), streamEventsSlice.Status.ToString()),
streamEventsSlice.FromEventNumber,
streamEventsSlice.NextEventNumber,
streamEventsSlice.LastEventNumber,
GetReadDirection(streamEventsSlice.ReadDirection),
streamEventsSlice.IsEndOfStream, streamEventsSlice
.Events
.Select(resolvedEvent => resolvedEvent.ToSteamEvent())
.ToArray());
}
public async Task<AllEventsPage> ReadAll(
Checkpoint checkpoint,
int maxCount,
ReadDirection direction = ReadDirection.Forward,
CancellationToken cancellationToken = default(CancellationToken))
{
Ensure.That(checkpoint, "checkpoint").IsNotNull();
var connection = _getConnection();
var position = checkpoint.ParsePosition();
AllEventsSlice allEventsSlice;
if (direction == ReadDirection.Forward)
{
allEventsSlice = await connection
.ReadAllEventsForwardAsync(position, maxCount, resolveLinkTos: false)
.NotOnCapturedContext();
}
else
{
allEventsSlice = await connection
.ReadAllEventsBackwardAsync(position, maxCount, resolveLinkTos: false)
.NotOnCapturedContext();
}
var events = allEventsSlice
.Events
.Where(@event =>
!(@event.OriginalEvent.EventType.StartsWith("$")
|| @event.OriginalStreamId.StartsWith("$")))
.Select(resolvedEvent =>resolvedEvent.ToSteamEvent())
.ToArray();
return new AllEventsPage(
allEventsSlice.FromPosition.ToString(),
allEventsSlice.NextPosition.ToString(),
allEventsSlice.IsEndOfStream,
GetReadDirection(allEventsSlice.ReadDirection),
events);
}
private async Task <ReadStreamPage> ReadStreamInternal(
MySqlStreamId streamId,
int start,
int count,
ReadDirection direction,
bool prefetch,
ReadNextStreamPage readNext,
MySqlTransaction transaction,
CancellationToken cancellationToken)
{
// If the count is int.MaxValue, TSql will see it as a negative number.
// Users shouldn't be using int.MaxValue in the first place anyway.
count = count == int.MaxValue ? count - 1 : count;
// To read backwards from end, need to use int MaxValue
var streamVersion = start == StreamVersion.End ? int.MaxValue : start;
var messages = new List <(StreamMessage message, int?maxAge)>();
string procedure;
Func <List <StreamMessage>, int, int> getNextVersion;
if (direction == ReadDirection.Forward)
{
procedure = prefetch ? _schema.ReadStreamForwardsWithData : _schema.ReadStreamForwards;
getNextVersion = (events, lastVersion) => events.Any()
? events.Last().StreamVersion + 1
: lastVersion + 1;
}
else
{
procedure = prefetch ? _schema.ReadStreamBackwardsWithData : _schema.ReadStreamBackwards;
getNextVersion = (events, lastVersion) => events.Any()
? events.Last().StreamVersion - 1
: -1;
}
using (var command = BuildStoredProcedureCall(
procedure,
transaction,
Parameters.StreamId(streamId),
Parameters.Count(count + 1),
Parameters.Version(streamVersion)))
using (var reader = await command
.ExecuteReaderAsync(CommandBehavior.SequentialAccess, cancellationToken)
.NotOnCapturedContext())
{
if (!reader.HasRows)
{
return(new ReadStreamPage(
streamId.IdOriginal,
PageReadStatus.StreamNotFound,
start,
-1,
-1,
-1,
direction,
true,
readNext));
}
if (messages.Count == count)
{
messages.Add(default);
private async Task <ReadStreamPage> ReadStreamInternal(
SqlStreamId sqlStreamId,
int start,
int count,
ReadDirection direction,
bool prefetch,
ReadNextStreamPage readNext,
SqlConnection connection, CancellationToken cancellationToken)
{
// If the count is int.MaxValue, TSql will see it as a negative number.
// Users shouldn't be using int.MaxValue in the first place anyway.
count = count == int.MaxValue ? count - 1 : count;
// To read backwards from end, need to use int MaxValue
var streamVersion = start == StreamVersion.End ? int.MaxValue : start;
string commandText;
Func <List <StreamMessage>, int, int> getNextVersion;
if (direction == ReadDirection.Forward)
{
commandText = prefetch ? _scripts.ReadStreamForwardWithData : _scripts.ReadStreamForward;
getNextVersion = (events, lastVersion) =>
{
if (events.Any())
{
return(events.Last().StreamVersion + 1);
}
return(lastVersion + 1);
};
}
else
{
commandText = prefetch ? _scripts.ReadStreamBackwardWithData : _scripts.ReadStreamBackward;
getNextVersion = (events, lastVersion) =>
{
if (events.Any())
{
return(events.Last().StreamVersion - 1);
}
return(-1);
};
}
using (var command = new SqlCommand(commandText, connection))
{
command.Parameters.AddWithValue("streamId", sqlStreamId.Id);
command.Parameters.AddWithValue("count", count + 1); //Read extra row to see if at end or not
command.Parameters.AddWithValue("streamVersion", streamVersion);
using (var reader = await command.ExecuteReaderAsync(cancellationToken).NotOnCapturedContext())
{
await reader.ReadAsync(cancellationToken).NotOnCapturedContext();
if (reader.IsDBNull(0))
{
return(new ReadStreamPage(
sqlStreamId.IdOriginal,
PageReadStatus.StreamNotFound,
start,
-1,
-1,
direction,
true,
StreamMessage.EmptyArray,
readNext));
}
var lastStreamVersion = reader.GetInt32(0);
await reader.NextResultAsync(cancellationToken).NotOnCapturedContext();
var messages = new List <StreamMessage>();
while (await reader.ReadAsync(cancellationToken).NotOnCapturedContext())
{
var streamVersion1 = reader.GetInt32(0);
var ordinal = reader.GetInt64(1);
var eventId = reader.GetGuid(2);
var created = reader.GetDateTime(3);
var type = reader.GetString(4);
var jsonMetadata = reader.GetString(5);
Func <CancellationToken, Task <string> > getJsonData;
if (prefetch)
{
var jsonData = reader.GetString(6);
getJsonData = _ => Task.FromResult(jsonData);
}
else
{
getJsonData = ct => GetJsonData(sqlStreamId.Id, streamVersion1, ct);
}
var message = new StreamMessage(
sqlStreamId.IdOriginal,
eventId,
streamVersion1,
ordinal,
created,
type,
jsonMetadata, getJsonData);
messages.Add(message);
}
var isEnd = true;
if (messages.Count == count + 1)
{
isEnd = false;
messages.RemoveAt(count);
}
return(new ReadStreamPage(
sqlStreamId.IdOriginal,
PageReadStatus.Success,
start,
getNextVersion(messages, lastStreamVersion),
lastStreamVersion,
direction,
isEnd,
messages.ToArray(),
readNext));
}
}
}
public Task <AllEventsPage> ReadAll(ICheckpoint checkpoint, int maxCount, ReadDirection direction = ReadDirection.Forward, CancellationToken cancellationToken = default(CancellationToken))
{
throw new NotImplementedException();
}
private async Task <ReadStreamPage> ReadStreamInternal(
PostgresqlStreamId streamId,
int start,
int count,
ReadDirection direction,
bool prefetch,
ReadNextStreamPage readNext,
NpgsqlTransaction transaction,
CancellationToken cancellationToken)
{
// If the count is int.MaxValue, TSql will see it as a negative number.
// Users shouldn't be using int.MaxValue in the first place anyway.
count = count == int.MaxValue ? count - 1 : count;
// To read backwards from end, need to use int MaxValue
var streamVersion = start == StreamVersion.End ? int.MaxValue : start;
var messages = new List <(StreamMessage message, int?maxAge)>();
Func <List <StreamMessage>, int, int> getNextVersion;
if (direction == ReadDirection.Forward)
{
getNextVersion = (events, lastVersion) =>
{
if (events.Any())
{
return(events.Last().StreamVersion + 1);
}
return(lastVersion + 1);
};
}
else
{
getNextVersion = (events, lastVersion) =>
{
if (events.Any())
{
return(events.Last().StreamVersion - 1);
}
return(-1);
};
}
var refcursorSql = new StringBuilder();
using (var command = BuildFunctionCommand(
_schema.Read,
transaction,
Parameters.StreamId(streamId),
Parameters.Count(count + 1),
Parameters.Version(streamVersion),
Parameters.ReadDirection(direction),
Parameters.Prefetch(prefetch)))
using (var reader = await command
.ExecuteReaderAsync(CommandBehavior.SequentialAccess, cancellationToken)
.ConfigureAwait(false))
{
while (await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
{
refcursorSql.AppendLine(Schema.FetchAll(reader.GetString(0)));
}
}
using (var command = new NpgsqlCommand(refcursorSql.ToString(), transaction.Connection, transaction))
using (var reader = await command
.ExecuteReaderAsync(CommandBehavior.SequentialAccess, cancellationToken)
.ConfigureAwait(false))
{
if (!reader.HasRows)
{
return(new ReadStreamPage(
streamId.IdOriginal,
PageReadStatus.StreamNotFound,
start,
-1,
-1,
-1,
direction,
true,
readNext));
}
if (messages.Count == count)
{
messages.Add(default);
public static CosmosStream Create(string id, string type, Version version, StreamReadStatus streamReadStatus,
ReadDirection readDirection, CosmosEvent[] events) =>
new CosmosStream(id, type, version, streamReadStatus, readDirection, events);
public IList<IChangeLogItem> GetChanges(ChangeLogQueryInfo queryInfo, ReadDirection direction, SortOrder order)
{
return new List<IChangeLogItem>();
}
public Task <IReadOnlyList <StreamMessage> > Read(
ReadDirection direction,
long?index,
long maxCount,
bool prefectchMessageBody,
CancellationToken cancellationToken = default
)
{
using (var command = CreateCommand())
{
var messages = new List <StreamMessage>();
command.CommandText = @"SELECT streams.id_original As stream_id,
messages.stream_version,
messages.position,
messages.event_id,
messages.created_utc,
messages.type,
messages.json_metadata,
CASE WHEN @includeJsonData = true THEN messages.json_data ELSE null END
FROM messages
INNER JOIN streams
ON messages.stream_id_internal = streams.id_internal
WHERE
CASE WHEN @readForward THEN messages.position >= @position ELSE messages.position <= @position END
ORDER BY
CASE WHEN @readForward THEN messages.position ELSE -messages.position END
LIMIT @count;";
command.Parameters.Clear();
command.Parameters.AddWithValue("@position", index);
command.Parameters.AddWithValue("@count", maxCount);
command.Parameters.AddWithValue("@includeJsonData", prefectchMessageBody);
command.Parameters.AddWithValue("@readForward", direction == ReadDirection.Forward);
var reader = command.ExecuteReader(CommandBehavior.SequentialAccess);
while (reader.Read())
{
var streamId = reader.GetString(0);
var streamVersion = reader.GetInt32(1);
var position = reader.IsDBNull(2) ? Position.End : reader.GetInt64(2);
var messageId = reader.GetGuid(3);
var created = reader.GetDateTime(4);
var type = reader.GetString(5);
var jsonMetadata = reader.GetString(6);
var preloadJson = (!reader.IsDBNull(7) && prefectchMessageBody)
? reader.GetTextReader(7).ReadToEnd()
: default;
var message = new StreamMessage(streamId,
messageId,
streamVersion,
position,
created,
type,
jsonMetadata,
ct => prefectchMessageBody
? Task.FromResult(preloadJson)
: SqliteCommandExtensions.GetJsonData(streamId, streamVersion));
messages.Add(message);
}
return(Task.FromResult <IReadOnlyList <StreamMessage> >(messages));
}
}
private Task <ReadStreamPage> PrepareStreamResponse(
SqliteConnection connection,
string streamId,
ReadDirection direction,
int fromVersion,
bool prefetch,
ReadNextStreamPage readNext,
int maxRecords,
int?maxAge)
{
// If the count is int.MaxValue, TSql will see it as a negative number.
// Users shouldn't be using int.MaxValue in the first place anyway.
maxRecords = maxRecords == int.MaxValue ? maxRecords - 1 : maxRecords;
var streamVersion = fromVersion == StreamVersion.End ? int.MaxValue - 1 : fromVersion;
int nextVersion = 0;
var stream = connection.Streams(streamId);
var header = stream
.Properties()
.GetAwaiter().GetResult();
var position = stream
.AllStreamPosition(direction, streamVersion)
.GetAwaiter().GetResult();
var remaining = stream
.Length(direction, position, CancellationToken.None)
.GetAwaiter().GetResult();
var messages = stream
.Read(direction, position, prefetch, maxRecords)
.GetAwaiter().GetResult()
.Select(Message => (Message, maxAge))
.ToList();
var filtered = FilterExpired(messages);
var isEnd = remaining - messages.Count <= 0;
if (direction == ReadDirection.Forward)
{
if (messages.Any())
{
nextVersion = messages.Last().Message.StreamVersion + 1;
}
else
{
nextVersion = header.Version + 1;
}
}
else if (direction == ReadDirection.Backward)
{
if (streamVersion == int.MaxValue - 1 && !messages.Any())
{
nextVersion = StreamVersion.End;
}
if (messages.Any())
{
nextVersion = messages.Last().Message.StreamVersion - 1;
}
}
var page = new ReadStreamPage(
streamId,
status: PageReadStatus.Success,
fromStreamVersion: fromVersion,
nextStreamVersion: nextVersion,
lastStreamVersion: header.Version,
lastStreamPosition: header.Position,
direction: direction,
isEnd: isEnd,
readNext: readNext,
messages: filtered.ToArray());
return(Task.FromResult(page));
}
public async Task<StreamEventsPage> ReadStream(
string streamId,
int start,
int count,
ReadDirection direction = ReadDirection.Forward,
CancellationToken cancellationToken = default(CancellationToken))
{
CheckIfDisposed();
var connection = _getConnection();
StreamEventsSlice streamEventsSlice;
if(direction == ReadDirection.Forward)
{
streamEventsSlice = await connection
.ReadStreamEventsForwardAsync(streamId, start, count, true)
.NotOnCapturedContext();
}
else
{
streamEventsSlice = await connection
.ReadStreamEventsBackwardAsync(streamId, start, count, true)
.NotOnCapturedContext();
}
return new StreamEventsPage(
streamId,
(PageReadStatus) Enum.Parse(typeof(PageReadStatus), streamEventsSlice.Status.ToString()),
streamEventsSlice.FromEventNumber,
streamEventsSlice.NextEventNumber,
streamEventsSlice.LastEventNumber,
GetReadDirection(streamEventsSlice.ReadDirection),
streamEventsSlice.IsEndOfStream,
streamEventsSlice
.Events
.Select(resolvedEvent => resolvedEvent.ToSteamEvent())
.ToArray());
}
internal AllEventsSlice(ReadDirection readDirection, Position fromPosition, Position nextPosition,
ClientMessage.ResolvedEvent[] events) : this(readDirection, fromPosition, nextPosition, events,
events == null || events.Length == 0)
{
}
/// <summary>
/// Sets _rows and _cols collections to point to _tiles[,] elements
/// </summary>
private void PointRowsAndColsToArrayElements(List<ITileAccessor> tileAccessorCollection, ReadDirection readDirection, ref TilesBuffer buffer)
{
for (int i = 0; i < 4; i++)
{
if (tileAccessorCollection.Count < 4)
tileAccessorCollection.Add(new TileAccessor(i, readDirection, ref buffer));
else
tileAccessorCollection[i].AttachToTiles(ref buffer);
}
}
public ReadStreamTheory(
string streamId,
int start,
ReadDirection direction,
int pageSize,
StreamEventsPage expectedStreamEventsPage)
{
StreamId = streamId;
Start = start;
Direction = direction;
PageSize = pageSize;
ExpectedStreamEventsPage = expectedStreamEventsPage;
}
