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