Upgrade to Scylla 0.11.1 (#44)

* Upgrade to Scylla 0.11.1
Jasperav · Dec 27, 2023 · f6cedf0 · f6cedf0
1 parent 6b74c52
commit f6cedf0
Show file tree

Hide file tree

Showing 20 changed files with 218 additions and 115 deletions.
diff --git a/.github/workflows/scylla.yml b/.github/workflows/scylla.yml
@@ -15,7 +15,7 @@ jobs:
     # Locally scylla can be started like so: docker run --name scylla -p 19042:19042 -p 9042:9042 --rm scylladb/scylla
     services:
       scylladb:
-        image: scylladb/scylla
+        image: scylladb/scylla:5.4
         ports:
           - 9042:9042
           - 19042:19042

diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -10,7 +10,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.1.20"
+version = "0.1.21"
 authors = ["Jasper Visser <jasperav@hotmail.com>"]
 repository = "https://github.com/Jasperav/catalytic"
 readme = "./README.md"
@@ -19,7 +19,7 @@ categories = ["database"]
 license = "MIT"
 
 [workspace.dependencies]
-scylla = "0.10.1" # This crate is specifically build for this version
+scylla = "0.11.1" # This crate is specifically build for this version
 once_cell = "1"
 heck = "0.4"
 tokio = { version = "1", features = ["time", "rt-multi-thread", "io-util"] }

diff --git a/catalytic/src/query_transform.rs b/catalytic/src/query_transform.rs
@@ -3,9 +3,9 @@
 /// methods, but specific methods, like 'update', 'delete' etc
 use crate::Cursor;
 use futures_util::{StreamExt, TryStreamExt};
+use scylla::_macro_internal::{LegacySerializedValues, SerializeRow};
 use scylla::cql_to_rust::FromRowError;
-use scylla::frame::value::SerializedValues;
-use scylla::frame::value::{SerializeValuesError, ValueList};
+use scylla::frame::value::SerializeValuesError;
 use scylla::query::Query;
 use scylla::transport::errors::QueryError;
 use scylla::transport::iterator::TypedRowIterator;
@@ -199,12 +199,12 @@ impl<T: FromRow> QueryResultUniqueRowExpect<T> {
     }
 }
 
-pub struct Qv<R: AsRef<str> = &'static str, V: ValueList = SerializedValues> {
+pub struct Qv<R: AsRef<str> = &'static str, V: SerializeRow = LegacySerializedValues> {
     pub query: R,
     pub values: V,
 }
 
-impl<R: AsRef<str> + Clone, V: ValueList + Clone> Clone for Qv<R, V> {
+impl<R: AsRef<str> + Clone, V: SerializeRow + Clone> Clone for Qv<R, V> {
     fn clone(&self) -> Self {
         Qv {
             query: self.query.clone(),
@@ -213,15 +213,15 @@ impl<R: AsRef<str> + Clone, V: ValueList + Clone> Clone for Qv<R, V> {
     }
 }
 
-impl<R: AsRef<str>, V: ValueList> Debug for Qv<R, V> {
+impl<R: AsRef<str>, V: SerializeRow> Debug for Qv<R, V> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Qv")
             .field("query", &self.query.as_ref())
             .finish()
     }
 }
 
-impl<R: AsRef<str>, V: ValueList> Qv<R, V> {
+impl<R: AsRef<str>, V: SerializeRow> Qv<R, V> {
     async fn execute(&self, session: &CachingSession) -> ScyllaQueryResult {
         let as_ref = self.query.as_ref();
 
@@ -339,10 +339,10 @@ impl<R: AsRef<str>, V: ValueList> Qv<R, V> {
 macro_rules! simple_qv_holder {
     ($ ident : ident , $ method : ident) => {
         #[derive(Debug)]
-        pub struct $ident<R: AsRef<str> = &'static str, V: ValueList = SerializedValues> {
+        pub struct $ident<R: AsRef<str> = &'static str, V: SerializeRow = LegacySerializedValues> {
             pub qv: Qv<R, V>,
         }
-        impl<R: AsRef<str>, V: ValueList> $ident<R, V> {
+        impl<R: AsRef<str>, V: SerializeRow> $ident<R, V> {
             pub fn new(qv: Qv<R, V>) -> Self {
                 Self { qv }
             }
@@ -352,15 +352,15 @@ macro_rules! simple_qv_holder {
             }
         }
 
-        impl<R: AsRef<str>, V: ValueList> Deref for $ident<R, V> {
+        impl<R: AsRef<str>, V: SerializeRow> Deref for $ident<R, V> {
             type Target = Qv<R, V>;
 
             fn deref(&self) -> &Self::Target {
                 &self.qv
             }
         }
 
-        impl<R: AsRef<str> + Clone, V: ValueList + Clone> Clone for $ident<R, V> {
+        impl<R: AsRef<str> + Clone, V: SerializeRow + Clone> Clone for $ident<R, V> {
             fn clone(&self) -> Self {
                 $ident::new(self.qv.clone())
             }
@@ -376,27 +376,30 @@ simple_qv_holder!(Truncate, truncate);
 macro_rules! read_transform {
     ($ ident : ident) => {
         #[derive(Debug)]
-        pub struct $ident<T: FromRow, R: AsRef<str> = &'static str, V: ValueList = SerializedValues>
-        {
+        pub struct $ident<
+            T: FromRow,
+            R: AsRef<str> = &'static str,
+            V: SerializeRow = LegacySerializedValues,
+        > {
             pub qv: Qv<R, V>,
             p: PhantomData<T>,
         }
 
-        impl<T: FromRow, R: AsRef<str>, V: ValueList> $ident<T, R, V> {
+        impl<T: FromRow, R: AsRef<str>, V: SerializeRow> $ident<T, R, V> {
             pub fn new(qv: Qv<R, V>) -> $ident<T, R, V> {
                 $ident { qv, p: PhantomData }
             }
         }
 
-        impl<T: FromRow, R: AsRef<str>, V: ValueList> Deref for $ident<T, R, V> {
+        impl<T: FromRow, R: AsRef<str>, V: SerializeRow> Deref for $ident<T, R, V> {
             type Target = Qv<R, V>;
 
             fn deref(&self) -> &Self::Target {
                 &self.qv
             }
         }
 
-        impl<T: FromRow, R: AsRef<str> + Clone, V: ValueList + Clone> Clone for $ident<T, R, V> {
+        impl<T: FromRow, R: AsRef<str> + Clone, V: SerializeRow + Clone> Clone for $ident<T, R, V> {
             fn clone(&self) -> Self {
                 $ident::new(self.qv.clone())
             }
@@ -407,7 +410,7 @@ read_transform!(SelectMultiple);
 read_transform!(SelectUnique);
 read_transform!(SelectUniqueExpect);
 
-impl<T: FromRow, R: AsRef<str>, V: ValueList> SelectUnique<T, R, V> {
+impl<T: FromRow, R: AsRef<str>, V: SerializeRow> SelectUnique<T, R, V> {
     pub fn expect(self) -> SelectUniqueExpect<T, R, V> {
         SelectUniqueExpect::new(self.qv)
     }
@@ -423,7 +426,7 @@ impl<T: FromRow, R: AsRef<str>, V: ValueList> SelectUnique<T, R, V> {
     }
 }
 
-impl<T: FromRow, R: AsRef<str>, V: ValueList> SelectUniqueExpect<T, R, V> {
+impl<T: FromRow, R: AsRef<str>, V: SerializeRow> SelectUniqueExpect<T, R, V> {
     pub async fn select(
         &self,
         session: &CachingSession,
@@ -435,7 +438,7 @@ impl<T: FromRow, R: AsRef<str>, V: ValueList> SelectUniqueExpect<T, R, V> {
     }
 }
 
-impl<R: AsRef<str>, V: ValueList> SelectUniqueExpect<Count, R, V> {
+impl<R: AsRef<str>, V: SerializeRow> SelectUniqueExpect<Count, R, V> {
     pub async fn select_count(
         &self,
         session: &CachingSession,
@@ -448,7 +451,7 @@ impl<R: AsRef<str>, V: ValueList> SelectUniqueExpect<Count, R, V> {
     }
 }
 
-impl<T: FromRow, R: AsRef<str>, V: ValueList> SelectMultiple<T, R, V> {
+impl<T: FromRow, R: AsRef<str>, V: SerializeRow> SelectMultiple<T, R, V> {
     pub async fn select(
         &self,
         session: &CachingSession,

diff --git a/catalytic/src/runtime.rs b/catalytic/src/runtime.rs
@@ -1,8 +1,8 @@
 use crate::env_property_reader::{database_url, keyspace, password, username};
 use once_cell::sync::Lazy;
+use scylla::_macro_internal::SerializeRow;
 use scylla::execution_profile::ExecutionProfileBuilder;
 use scylla::frame::types::Consistency;
-use scylla::frame::value::ValueList;
 use scylla::query::Query;
 use scylla::{FromRow, IntoTypedRows, Session, SessionBuilder};
 use tokio::runtime::{self, Runtime};
@@ -21,7 +21,7 @@ pub static RUNTIME: Lazy<Runtime> = Lazy::new(|| {
 
 pub fn query_collect_to_vec<Entity: FromRow>(
     query: impl Into<Query>,
-    values: impl ValueList,
+    values: impl SerializeRow,
 ) -> Vec<Entity> {
     touch_global_connection();
 
@@ -38,7 +38,7 @@ pub fn query_collect_to_vec<Entity: FromRow>(
     })
 }
 
-pub fn query(query: impl Into<Query>, values: impl ValueList) {
+pub fn query(query: impl Into<Query>, values: impl SerializeRow) {
     touch_global_connection();
 
     block_on(async move { GLOBAL_CONNECTION.query(query, values).await.unwrap() });