Update scylla dependency

crates/scyllaconn/src/accounting/toplist.rs

@@ -3,14 +3,15 @@ use futures_util::TryStreamExt;
 use netpod::ttl::RetentionTime;
 use netpod::TsMs;
 use netpod::EMIT_ACCOUNTING_SNAP;
-use scylla::prepared_statement::PreparedStatement;
-use scylla::Session as ScySession;
+use scylla::client::session::Session as ScySession;
+use scylla::statement::prepared::PreparedStatement;
 
 autoerr::create_error_v1!(
     name(Error, "AccountingToplist"),
     enum variants {
-        ScyllaQuery(#[from] scylla::transport::errors::QueryError),
-        ScyllaNextRow(#[from] scylla::transport::iterator::NextRowError),
+        ScyllaPrepare(#[from] scylla::errors::PrepareError),
+        ScyllaPagerExecution(#[from] scylla::errors::PagerExecutionError),
+        ScyllaNextRow(#[from] scylla::errors::NextRowError),
         ScyllaTypeCheck(#[from] scylla::deserialize::TypeCheckError),
         UsageDataMalformed,
     },

crates/scyllaconn/src/accounting/totals.rs

@@ -13,14 +13,15 @@ use netpod::log::*;
 use netpod::range::evrange::NanoRange;
 use netpod::timeunits;
 use netpod::EMIT_ACCOUNTING_SNAP;
-use scylla::prepared_statement::PreparedStatement;
-use scylla::Session as ScySession;
+use scylla::statement::prepared::PreparedStatement;
 use std::collections::VecDeque;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::Context;
 use std::task::Poll;
 
+type ScySession = scylla::client::session::Session;
+
 async fn read_next(
     ts_msp: u64,
     fwd: bool,

crates/scyllaconn/src/bincache.rs

@@ -9,10 +9,11 @@ use items_2::binning::container_bins::ContainerBins;
 use netpod::ttl::RetentionTime;
 use netpod::DtMs;
 use netpod::TsNano;
-use scylla::Session as ScySession;
 use std::ops::Range;
 use streams::timebin::cached::reader::BinsReadRes;
 
+type ScySession = scylla::client::session::Session;
+
 async fn scylla_read_prebinned_f32(
     series: u64,
     bin_len: DtMs,

crates/scyllaconn/src/conn.rs

@@ -3,12 +3,13 @@ use daqbuf_err as err;
 use err::Error;
 use netpod::log::*;
 use netpod::ScyllaConfig;
-use scylla::execution_profile::ExecutionProfileBuilder;
+use scylla::client::execution_profile::ExecutionProfileBuilder;
+use scylla::client::session::Session;
+use scylla::client::session_builder::SessionBuilder;
 use scylla::statement::Consistency;
-use scylla::Session as ScySession;
 use std::sync::Arc;
 
-pub async fn create_scy_session(scyconf: &ScyllaConfig) -> Result<Arc<ScySession>, Error> {
+pub async fn create_scy_session(scyconf: &ScyllaConfig) -> Result<Arc<Session>, Error> {
     let scy = create_scy_session_no_ks(scyconf).await?;
     scy.use_keyspace(&scyconf.keyspace, true)
         .await
@@ -17,9 +18,9 @@ pub async fn create_scy_session(scyconf: &ScyllaConfig) -> Result<Arc<ScySession
     Ok(ret)
 }
 
-pub async fn create_scy_session_no_ks(scyconf: &ScyllaConfig) -> Result<ScySession, Error> {
+pub async fn create_scy_session_no_ks(scyconf: &ScyllaConfig) -> Result<Session, Error> {
     info!("creating scylla connection");
-    let scy = scylla::SessionBuilder::new()
+    let scy = SessionBuilder::new()
         .known_nodes(&scyconf.hosts)
         .default_execution_profile_handle(
             ExecutionProfileBuilder::default()

crates/scyllaconn/src/errconv.rs

@@ -1,7 +1,5 @@
 use daqbuf_err as err;
 use err::Error;
-use scylla::transport::errors::NewSessionError as ScyNewSessionError;
-use scylla::transport::errors::QueryError as ScyQueryError;
 
 pub trait ErrConv<T> {
     fn err_conv(self) -> Result<T, Error>;
@@ -15,29 +13,39 @@ impl<T, A> ErrConv<T> for Result<T, async_channel::SendError<A>> {
         }
     }
 }
-impl<T> ErrConv<T> for Result<T, ScyQueryError> {
-    fn err_conv(self) -> Result<T, Error> {
-        match self {
-            Ok(k) => Ok(k),
-            Err(e) => Err(Error::with_msg_no_trace(format!("{e:?}"))),
-        }
-    }
-}
-
-impl<T> ErrConv<T> for Result<T, ScyNewSessionError> {
-    fn err_conv(self) -> Result<T, Error> {
-        match self {
-            Ok(k) => Ok(k),
-            Err(e) => Err(Error::with_msg_no_trace(format!("{e:?}"))),
-        }
-    }
-}
 
 impl<T> ErrConv<T> for Result<T, scylla::deserialize::TypeCheckError> {
     fn err_conv(self) -> Result<T, Error> {
         match self {
             Ok(k) => Ok(k),
-            Err(e) => Err(Error::with_msg_no_trace(format!("{e:?}"))),
+            Err(e) => Err(Error::with_msg_no_trace(format!("{:?}", e))),
+        }
+    }
+}
+
+impl<T> ErrConv<T> for Result<T, scylla::errors::PagerExecutionError> {
+    fn err_conv(self) -> Result<T, Error> {
+        match self {
+            Ok(k) => Ok(k),
+            Err(e) => Err(Error::with_msg_no_trace(format!("{:?}", e))),
+        }
+    }
+}
+
+impl<T> ErrConv<T> for Result<T, scylla::errors::NextRowError> {
+    fn err_conv(self) -> Result<T, Error> {
+        match self {
+            Ok(k) => Ok(k),
+            Err(e) => Err(Error::with_msg_no_trace(format!("{:?}", e))),
+        }
+    }
+}
+
+impl<T> ErrConv<T> for Result<T, scylla::errors::NewSessionError> {
+    fn err_conv(self) -> Result<T, Error> {
+        match self {
+            Ok(k) => Ok(k),
+            Err(e) => Err(Error::with_msg_no_trace(format!("{:?}", e))),
         }
     }
 }

crates/scyllaconn/src/events2/events.rs

@@ -29,7 +29,7 @@ use netpod::Shape;
 use netpod::TsMs;
 use netpod::TsMsVecFmt;
 use netpod::TsNano;
-use scylla::Session;
+use scylla::client::session::Session;
 use std::collections::VecDeque;
 use std::fmt;
 use std::pin::Pin;
@@ -96,10 +96,10 @@ autoerr::create_error_v1!(
         RangeEndOverflow,
         NotTokenAware,
         Prepare(#[from] crate::events2::prepare::Error),
-        ScyllaQuery(#[from] scylla::transport::errors::QueryError),
-        ScyllaNextRow(#[from] scylla::transport::iterator::NextRowError),
+        ScyllaNextRow(#[from] scylla::errors::NextRowError),
         ScyllaWorker(Box<crate::worker::Error>),
         ScyllaTypeCheck(#[from] scylla::deserialize::TypeCheckError),
+        ScyllaPagerExecution(#[from] scylla::errors::PagerExecutionError),
     },
 );
 
@@ -1070,8 +1070,8 @@ where
 
 trait ValTy: Sized + 'static {
     type ScaTy: ScalarOps + std::default::Default;
-    type ScyTy: for<'a, 'b> scylla::deserialize::DeserializeValue<'a, 'b>;
-    type ScyRowTy: for<'a, 'b> scylla::deserialize::DeserializeRow<'a, 'b>;
+    type ScyTy: for<'a, 'b> scylla::deserialize::value::DeserializeValue<'a, 'b>;
+    type ScyRowTy: for<'a, 'b> scylla::deserialize::row::DeserializeRow<'a, 'b>;
     type Container: BinningggContainerEventsDyn + Empty + Appendable<Self>;
     fn from_valueblob(inp: Vec<u8>) -> Self;
     fn table_name() -> &'static str;

crates/scyllaconn/src/events2/msp.rs

@@ -10,7 +10,7 @@ use netpod::log;
 use netpod::ttl::RetentionTime;
 use netpod::TsMs;
 use netpod::TsMsVecFmt;
-use scylla::Session;
+use scylla::client::session::Session;
 use std::collections::VecDeque;
 use std::pin::Pin;
 use std::task::Context;
@@ -25,9 +25,9 @@ autoerr::create_error_v1!(
     enum variants {
         Logic,
         Worker(Box<crate::worker::Error>),
-        ScyllaQuery(#[from] scylla::transport::errors::QueryError),
-        ScyllaRow(#[from] scylla::transport::iterator::NextRowError),
+        ScyllaRow(#[from] scylla::errors::NextRowError),
         ScyllaTypeCheck(#[from] scylla::deserialize::TypeCheckError),
+        ScyllaPagerExecution(#[from] scylla::errors::PagerExecutionError),
     },
 );
 
@@ -111,7 +111,7 @@ impl MspStreamRt {
             let range = range.clone();
             async move { scyqueue.find_ts_msp(rt, series.id(), range, false).await }
         };
-        let do_trace_detail = netpod::TRACE_SERIES_ID.contains(&series.id());
+        let do_trace_detail = daqbuf_series::dbg::dbg_series(series.clone());
         trace_emit!(do_trace_detail, "-------------------------------------  TEST TRACE");
         Self {
             rt,

crates/scyllaconn/src/events2/prepare.rs

@@ -1,13 +1,13 @@
 use netpod::ttl::RetentionTime;
-use scylla::prepared_statement::PreparedStatement;
-use scylla::Session;
+use scylla::client::session::Session;
+use scylla::statement::prepared::PreparedStatement;
 
 autoerr::create_error_v1!(
     name(Error, "ScyllaPrepare"),
     enum variants {
-        ScyllaQuery(#[from] scylla::transport::errors::QueryError),
-        ScyllaNextRow(#[from] scylla::transport::iterator::NextRowError),
+        ScyllaNextRow(#[from] scylla::errors::NextRowError),
         ScyllaWorker(Box<crate::worker::Error>),
+        ScyllaPrepare(#[from] scylla::errors::PrepareError),
         MissingQuery(String),
         RangeEndOverflow,
         InvalidFuture,

crates/scyllaconn/src/status.rs

@@ -15,7 +15,7 @@ use netpod::log::*;
 use netpod::range::evrange::NanoRange;
 use netpod::timeunits::MS;
 use netpod::CONNECTION_STATUS_DIV;
-use scylla::Session as ScySession;
+use scylla::client::session::Session as ScySession;
 use std::collections::VecDeque;
 use std::pin::Pin;
 use std::sync::Arc;

crates/scyllaconn/src/worker.rs

@@ -19,7 +19,7 @@ use netpod::ttl::RetentionTime;
 use netpod::DtMs;
 use netpod::ScyllaConfig;
 use netpod::TsMs;
-use scylla::Session;
+use scylla::client::session::Session;
 use std::collections::VecDeque;
 use std::fmt;
 use std::pin::Pin;
@@ -44,8 +44,9 @@ autoerr::create_error_v1!(
         Toplist(#[from] crate::accounting::toplist::Error),
         MissingKeyspaceConfig,
         CacheWriteF32(#[from] streams::timebin::cached::reader::Error),
-        ScyllaQuery(#[from] scylla::transport::errors::QueryError),
         ScyllaType(#[from] scylla::deserialize::TypeCheckError),
+        ScyllaNextRow(#[from] scylla::errors::NextRowError),
+        ScyllaPagerExecution(#[from] scylla::errors::PagerExecutionError),
     },
 );
 
@@ -55,7 +56,7 @@ impl<T> From<async_channel::SendError<T>> for Error {
     }
 }
 
-type ScySessTy = scylla::transport::session::GenericSession<scylla::transport::session::CurrentDeserializationApi>;
+type ScySessTy = scylla::client::session::Session;
 
 #[derive(Debug)]
 struct ReadPrebinnedF32 {