WIP

crates/scyllaconn/src/bincache.rs

@@ -245,14 +245,15 @@ pub async fn worker_write(
     scy: &ScySession,
 ) -> Result<(), streams::timebin::cached::reader::Error> {
     let mut msp_last = u64::MAX;
-    for (((((&ts1, &ts2), &cnt), &min), &max), &avg) in bins
+    for ((((((&ts1, &ts2), &cnt), &min), &max), &avg), &lst) in bins
         .ts1s
         .iter()
         .zip(bins.ts2s.iter())
-        .zip(bins.counts.iter())
+        .zip(bins.cnts.iter())
         .zip(bins.mins.iter())
         .zip(bins.maxs.iter())
         .zip(bins.avgs.iter())
+        .zip(bins.lsts.iter())
     {
         let bin_len = DtMs::from_ms_u64((ts2 - ts1) / 1000000);
         let div = streams::timebin::cached::reader::part_len(bin_len).ns();
@@ -267,6 +268,7 @@ pub async fn worker_write(
             min,
             max,
             avg,
+            lst,
         );
         // trace!("cache write {:?}", params);
         scy.execute(stmts_cache.st_write_f32(), params)
@@ -296,7 +298,7 @@ pub async fn worker_read(
         .execute_iter(stmts_cache.st_read_f32().clone(), params)
         .await
         .map_err(|e| streams::timebin::cached::reader::Error::Scylla(e.to_string()))?;
-    let mut it = res.into_typed::<(i32, i64, f32, f32, f32)>();
+    let mut it = res.into_typed::<(i32, i64, f32, f32, f32, f32)>();
     let mut bins = BinsDim0::empty();
     while let Some(x) = it.next().await {
         let row = x.map_err(|e| streams::timebin::cached::reader::Error::Scylla(e.to_string()))?;
@@ -305,9 +307,10 @@ pub async fn worker_read(
         let min = row.2;
         let max = row.3;
         let avg = row.4;
+        let lst = row.5;
         let ts1 = bin_len.ns() * off + div * msp;
         let ts2 = ts1 + bin_len.ns();
-        bins.push(ts1, ts2, cnt, min, max, avg);
+        bins.push(ts1, ts2, cnt, min, max, avg, lst);
     }
     Ok(bins)
 }

crates/scyllaconn/src/conn.rs

@@ -17,7 +17,7 @@ pub async fn create_scy_session(scyconf: &ScyllaConfig) -> Result<Arc<ScySession
 }
 
 pub async fn create_scy_session_no_ks(scyconf: &ScyllaConfig) -> Result<ScySession, Error> {
-    warn!("create_connection\n\n  CREATING SCYLLA CONNECTION\n\n");
+    warn!("creating scylla connection");
     let scy = scylla::SessionBuilder::new()
         .known_nodes(&scyconf.hosts)
         .default_execution_profile_handle(

crates/scyllaconn/src/events2/prepare.rs

@@ -262,8 +262,8 @@ impl StmtsCache {
             .prepare(format!(
                 concat!(
                     "insert into {}.{}binned_scalar_f32",
-                    " (series, bin_len_ms, ts_msp, off, count, min, max, avg)",
-                    " values (?, ?, ?, ?, ?, ?, ?, ?)"
+                    " (series, bin_len_ms, ts_msp, off, count, min, max, avg, lst)",
+                    " values (?, ?, ?, ?, ?, ?, ?, ?, ?)"
                 ),
                 ks,
                 rt.table_prefix()
@@ -272,7 +272,7 @@ impl StmtsCache {
         let st_read_f32 = scy
             .prepare(format!(
                 concat!(
-                    "select off, count, min, max, avg",
+                    "select off, count, min, max, avg, lst",
                     " from {}.{}binned_scalar_f32",
                     " where series = ?",
                     " and bin_len_ms = ?",

crates/scyllaconn/src/schema.rs

@@ -0,0 +1,15 @@
+use err::thiserror;
+use err::ThisError;
+use netpod::ttl::RetentionTime;
+use netpod::ScyllaConfig;
+use scylla::Session as ScySession;
+
+#[derive(Debug, ThisError)]
+#[cstm(name = "ScyllaSchema")]
+pub enum Error {
+    Scylla,
+}
+
+pub async fn schema(rt: RetentionTime, scyco: &ScyllaConfig, scy: &ScySession) -> Result<(), Error> {
+    todo!()
+}

crates/scyllaconn/src/scyllaconn.rs

@@ -5,6 +5,7 @@ pub mod errconv;
 pub mod events;
 pub mod events2;
 pub mod range;
+pub mod schema;
 pub mod status;
 pub mod worker;
 

crates/scyllaconn/src/worker.rs

@@ -33,6 +33,7 @@ pub enum Error {
     Toplist(#[from] crate::accounting::toplist::Error),
     MissingKeyspaceConfig,
     CacheWriteF32(#[from] streams::timebin::cached::reader::Error),
+    Schema(#[from] crate::schema::Error),
 }
 
 #[derive(Debug)]
@@ -212,6 +213,9 @@ impl ScyllaWorker {
             .await
             .map_err(Error::ScyllaConnection)?;
         let scy = Arc::new(scy);
+        crate::schema::schema(RetentionTime::Short, &self.scyconf_st, &scy).await?;
+        crate::schema::schema(RetentionTime::Medium, &self.scyconf_mt, &scy).await?;
+        crate::schema::schema(RetentionTime::Long, &self.scyconf_lt, &scy).await?;
         let kss = [
             self.scyconf_st.keyspace.as_str(),
             self.scyconf_mt.keyspace.as_str(),