Track last_modified for components

src/entity.rs

···
         self.try_component_names().unwrap()
     }
 
+    pub fn last_modified(&self) -> chrono::DateTime<chrono::Utc> {
+        self.try_last_modified().expect("Non-Error")
+    }
+
     #[tracing::instrument(name = "attach", level = "debug", skip_all)]
     pub fn try_attach<B: Bundle>(self, component: B) -> Result<Self, Error> {
         let components = B::to_rusqlite(component)?;
···
             .query_map(params![self.id()], |row| row.get(0))?
             .collect::<Result<Vec<_>, _>>()?;
         Ok(names.into_iter())
+    }
+
+    #[tracing::instrument(name = "last_modified", level = "debug")]
+    pub fn try_last_modified(&self) -> Result<chrono::DateTime<chrono::Utc>, Error> {
+        self.0.try_last_modified(self.id()).map_err(Error::from)
     }
 }
 

src/lib.rs

···
 pub use resource::*;
 
 mod system;
+use ::rusqlite::params;
 pub use system::*;
 
 use std::path::Path;
···
     ) -> Result<impl Iterator<Item = Entity<'a>> + 'a, Error> {
         let query = query::Query::<(), _>::new(self, components);
         query.try_into_iter()
+    }
+}
+
+impl Ecs {
+    /// Returns the highest `last_modified` from all components of `entity`.
+    /// Returns `chrono::DateTime::MIN_UTC` if `entity` has no components
+    fn try_last_modified(
+        &self,
+        entity: EntityId,
+    ) -> Result<chrono::DateTime<chrono::Utc>, rusqlite::Error> {
+        let mut stmt = self.conn.prepare_cached(
+            "select max(last_modified) as last_modified from components where entity = ?",
+        )?;
+
+        let last_modified = stmt
+            .query_map(params![&entity], |row| {
+                row.get::<_, String>("last_modified")
+            })?
+            .map(|dt| dt.expect("Valid chrono::DateTime"))
+            .next();
+
+        let last_modified = if let Some(last_modified) = last_modified {
+            chrono::DateTime::parse_from_rfc3339(&last_modified)
+                .expect("Valid chrono::DateTime")
+                .to_utc()
+        } else {
+            chrono::DateTime::<chrono::Utc>::MIN_UTC
+        };
+
+        Ok(last_modified)
     }
 }
 
···
         assert!(e2.matches::<A>());
         assert!(e2.matches::<B>());
         assert!(e2.matches::<(A, B)>());
+    }
+
+    #[test]
+    fn last_modified() {
+        #[derive(Serialize, Deserialize, Component)]
+        struct A;
+        #[derive(Serialize, Deserialize, Component)]
+        struct B;
+
+        let db = super::Ecs::open_in_memory().unwrap();
+        let e = db.new_entity().attach(A);
+
+        assert!(e.last_modified() > chrono::Utc::now() - chrono::Duration::minutes(1));
+
+        let old = e.last_modified();
+
+        std::thread::sleep(std::time::Duration::from_millis(2));
+
+        e.attach(B);
+        assert!(e.last_modified() > old);
     }
 }

src/migrations/01_last_modified.sql

···
+begin;
+
+alter table components
+rename to components_old;
+
+create table components (
+    entity integer not null,
+    component text not null,
+    data blob,
+    last_modified rfc3339 not null default (strftime ('%Y-%m-%dT%H:%M:%fZ'))
+);
+
+create unique index if not exists components_entity_component_unqiue_idx on components (entity, component);
+
+create index if not exists components_component_idx on components (component);
+
+insert into
+    components (entity, component, data)
+select
+    *
+from
+    components_old;
+
+create trigger if not exists components_last_modified_trigger before
+update on components for each row begin
+update components
+set
+    last_modified = strftime ('%Y-%m-%dT%H:%M:%fZ')
+where
+    entity = new.entity
+    and component = new.component;
+
+end;
+
+alter table resources
+rename to resources_old;
+
+create table resources (
+    name text not null unique,
+    data blob,
+    last_modified rfc3339 not null default (strftime ('%Y-%m-%dT%H:%M:%fZ'))
+);
+
+insert into
+    resources (name, data)
+select
+    *
+from
+    resources_old;
+
+create trigger if not exists resources_last_modified_trigger before
+update on resources for each row begin
+update resources
+set
+    last_modified = strftime ('%Y-%m-%dT%H:%M:%fZ')
+where
+    name = new.name;
+
+end;
+
+drop table components_old;
+
+drop table resources_old;
+
+commit;

src/schema.sql

···
 create table if not exists components (
     entity integer not null,
     component text not null,
-    data blob
+    data blob,
+    last_modified rfc3339 not null default (strftime ('%Y-%m-%dT%H:%M:%fZ'))
 );
 
 create unique index if not exists components_entity_component_unqiue_idx on components (entity, component);
 
 create index if not exists components_component_idx on components (component);
 
-create table if not exists resources (name text not null unique, data blob);
+create trigger if not exists components_last_modified_trigger before
+update on components for each row begin
+update components
+set
+    last_modified = strftime ('%Y-%m-%dT%H:%M:%fZ')
+where
+    entity = new.entity
+    and component = new.component;
+
+end;
+
+create table if not exists resources (
+    name text not null unique,
+    data blob,
+    last_modified rfc3339 not null default (strftime ('%Y-%m-%dT%H:%M:%fZ'))
+);
+
+create trigger if not exists resources_last_modified_trigger before
+update on resources for each row begin
+update resources
+set
+    last_modified = strftime ('%Y-%m-%dT%H:%M:%fZ')
+where
+    name = new.name;
+
+end;