Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

fix: use correct index for the conclusion feed. #561

Merged
merged 6 commits into from
Oct 11, 2024
Merged

fix: use correct index for the conclusion feed. #561

Show file tree
Hide file tree
Changes from 2 commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
c131d41
refactor: update conclusion feed test to highlight bugs
nathanielc Oct 10, 2024
ef9dc4a
fix: use correct delivered index
nathanielc Oct 10, 2024
7c34d06
fix: use correct delivered for unsigned init events
nathanielc Oct 10, 2024
fc4759c
fix: use 1 based highwater_mark values
nathanielc Oct 10, 2024
bc03421
refactor: make event access stateful
nathanielc Oct 10, 2024
ed542f2
refactor: use consistent naming of access types
nathanielc Oct 10, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 17 additions & 3 deletions event-svc/src/store/sql/access/event.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,7 @@ use ceramic_core::{event_id::InvalidEventId, Cid, EventId, NodeId};
use ceramic_event::unvalidated;
use ceramic_sql::sqlite::{SqlitePool, SqliteTransaction};
use ipld_core::ipld::Ipld;
use itertools::Itertools;
use recon::{AssociativeHash, HashCount, Key, Sha256a};

use crate::store::{
Expand Down Expand Up @@ -370,17 +371,30 @@ impl CeramicOneEvent {
all_blocks.iter().map(|row| row.block.clone()).collect(),
)
.await?;

// We need to match up the delivered index with each event. However all_blocks contains an
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We are keeping multiple copies of data in memory, can we move this logic in the SQL query itself?

    let max_highwater = sqlx::query_as::<_, DeliveredEventBlockRow>(
        r#"
        SELECT
            event_id,
            MAX(delivered) AS max_delivered,
            block_data
        FROM
            events_table
        WHERE
            delivered > ?  -- Only fetch events with a delivered value greater than the highwater mark
        GROUP BY
            event_id
        ORDER BY
            max_delivered ASC
        LIMIT ?
        "#,
    ) 
    ```
    What do you think? Is this a better approach?

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Then we can call,

.bind(highwater)
.bind(limit)
.fetch_all(pool.reader())
.await?
.into_iter()
.map(|row| {
        // Decode the CAR file from the block data
     ....

        // Add the parsed event to the list
     ....

      // Update the max highwater mark
    })
    .max()
    .unwrap_or(highwater); // Use the input highwater if no new events are found ```

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The challenge is that we need events, but we have to construct the events from the list of blocks that make up each event. So the all_block query needs to join with the blocks tables in order to get all the data. This PR doesn't change how much memory is needed (we were previously keeping a copy of the data in memory). I think optimizing this query should be future work.(If we find its a cause of slow down)

// item for each block within each event. We need to chunk all_blocks by event and then
// find the max delivered for each event. This will create an iterator of a single
// delivered value for each event. With that iterator we can zip it with the parsed block
// car files as there is a 1:1 mapping.
let event_chunks = all_blocks
.into_iter()
.chunk_by(|block| block.block.order_key.clone());
let delivered_iter = event_chunks
.into_iter()
.map(|(_, event_chunk)| event_chunk.map(|block| block.delivered).max());

let result: Result<Vec<EventRowDelivered>> = parsed
.into_iter()
.zip(all_blocks.iter())
.map(|((_, carfile), block)| {
.zip(delivered_iter)
.map(|((_, carfile), delivered)| {
let (cid, event) =
unvalidated::Event::<Ipld>::decode_car(carfile.as_slice(), false)
.map_err(|_| Error::new_fatal(anyhow!("Error parsing event row")))?;
Ok(EventRowDelivered {
cid,
event,
delivered: block.delivered,
delivered: delivered.expect("should always be one block per event"),
})
})
.collect();
Expand Down
Loading