Decouple table and column specs

examples/Cargo.toml

@@ -19,6 +19,7 @@ scylla = { path = "../scylla", features = [
     "num-bigint-04",
     "bigdecimal-04",
 ] }
+scylla-cql = { path = "../scylla-cql" }
 tokio = { version = "1.34", features = ["full"] }
 tracing = { version = "0.1.25", features = ["log"] }
 tracing-subscriber = { version = "0.3.14", features = ["env-filter"] }

examples/allocations.rs

@@ -1,5 +1,6 @@
 use anyhow::Result;
-use scylla::{statement::prepared_statement::PreparedStatement, Session, SessionBuilder};
+use scylla::transport::session::Session;
+use scylla::{statement::prepared_statement::PreparedStatement, SessionBuilder};
 use std::io::Write;
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::Arc;

examples/basic.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
-use futures::TryStreamExt;
-use scylla::macros::FromRow;
+use scylla::frame::response::result::Row;
 use scylla::transport::session::Session;
+use scylla::DeserializeRow;
 use scylla::SessionBuilder;
 use std::env;
 
@@ -53,39 +53,38 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT a, b, c FROM examples_ks.basic", &[])
         .await?
-        .into_typed::<(i32, i32, String)>();
+        .into_typed::<(i32, i32, String)>()?;
     while let Some((a, b, c)) = iter.try_next().await? {
         println!("a, b, c: {}, {}, {}", a, b, c);
     }
 
-    // Or as custom structs that derive FromRow
-    #[derive(Debug, FromRow)]
+    // Or as custom structs that derive DeserializeRow
+    #[allow(unused)]
+    #[derive(Debug, DeserializeRow)]
     struct RowData {
-        _a: i32,
-        _b: Option<i32>,
-        _c: String,
+        a: i32,
+        b: Option<i32>,
+        c: String,
     }
 
     let mut iter = session
         .query_iter("SELECT a, b, c FROM examples_ks.basic", &[])
         .await?
-        .into_typed::<RowData>();
+        .into_typed::<RowData>()?;
     while let Some(row_data) = iter.try_next().await? {
         println!("row_data: {:?}", row_data);
     }
 
     // Or simply as untyped rows
     let mut iter = session
         .query_iter("SELECT a, b, c FROM examples_ks.basic", &[])
-        .await?;
-    while let Some(row) = iter.try_next().await? {
+        .await?
+        .into_typed::<Row>()?;
+    while let Some(row) = iter.next().await.transpose()? {
         let a = row.columns[0].as_ref().unwrap().as_int().unwrap();
         let b = row.columns[1].as_ref().unwrap().as_int().unwrap();
         let c = row.columns[2].as_ref().unwrap().as_text().unwrap();
         println!("a, b, c: {}, {}, {}", a, b, c);
-
-        // Alternatively each row can be parsed individually
-        // let (a2, b2, c2) = row.into_typed::<(i32, i32, String)>() ?;
     }
 
     let metrics = session.get_metrics();

examples/compare-tokens.rs

@@ -51,7 +51,9 @@ async fn main() -> Result<()> {
                 (pk,),
             )
             .await?
-            .single_row_typed::<(i64,)>()?;
+            .into_rows_result()?
+            .expect("Got not Rows result")
+            .single_row()?;
         assert_eq!(t, qt);
         println!("token for {}: {}", pk, t);
     }

examples/cql-time-types.rs

@@ -3,7 +3,6 @@
 
 use anyhow::Result;
 use chrono::{DateTime, NaiveDate, NaiveTime, Utc};
-use futures::{StreamExt, TryStreamExt};
 use scylla::frame::response::result::CqlValue;
 use scylla::frame::value::{CqlDate, CqlTime, CqlTimestamp};
 use scylla::transport::session::Session;
@@ -44,7 +43,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT d from examples_ks.dates", &[])
         .await?
-        .into_typed::<(NaiveDate,)>();
+        .into_typed::<(NaiveDate,)>()?;
     while let Some(row_result) = iter.next().await {
         let (read_date,): (NaiveDate,) = match row_result {
             Ok(read_date) => read_date,
@@ -66,7 +65,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT d from examples_ks.dates", &[])
         .await?
-        .into_typed::<(time::Date,)>();
+        .into_typed::<(time::Date,)>()?;
     while let Some(row_result) = iter.next().await {
         let (read_date,): (time::Date,) = match row_result {
             Ok(read_date) => read_date,
@@ -88,7 +87,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT d from examples_ks.dates", &[])
         .await?
-        .into_typed::<(CqlValue,)>();
+        .into_typed::<(CqlValue,)>()?;
     while let Some(row_result) = iter.next().await {
         let read_days: u32 = match row_result {
             Ok((CqlValue::Date(CqlDate(days)),)) => days,
@@ -124,7 +123,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT d from examples_ks.times", &[])
         .await?
-        .into_typed::<(NaiveTime,)>();
+        .into_typed::<(NaiveTime,)>()?;
     while let Some((read_time,)) = iter.try_next().await? {
         println!("Parsed a time into chrono::NaiveTime: {:?}", read_time);
     }
@@ -139,7 +138,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT d from examples_ks.times", &[])
         .await?
-        .into_typed::<(time::Time,)>();
+        .into_typed::<(time::Time,)>()?;
     while let Some((read_time,)) = iter.try_next().await? {
         println!("Parsed a time into time::Time: {:?}", read_time);
     }
@@ -154,7 +153,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT d from examples_ks.times", &[])
         .await?
-        .into_typed::<(CqlTime,)>();
+        .into_typed::<(CqlTime,)>()?;
     while let Some((read_time,)) = iter.try_next().await? {
         println!("Read a time as raw nanos: {:?}", read_time);
     }
@@ -185,7 +184,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT d from examples_ks.timestamps", &[])
         .await?
-        .into_typed::<(DateTime<Utc>,)>();
+        .into_typed::<(DateTime<Utc>,)>()?;
     while let Some((read_time,)) = iter.try_next().await? {
         println!(
             "Parsed a timestamp into chrono::DateTime<chrono::Utc>: {:?}",
@@ -206,7 +205,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT d from examples_ks.timestamps", &[])
         .await?
-        .into_typed::<(time::OffsetDateTime,)>();
+        .into_typed::<(time::OffsetDateTime,)>()?;
     while let Some((read_time,)) = iter.try_next().await? {
         println!(
             "Parsed a timestamp into time::OffsetDateTime: {:?}",
@@ -227,7 +226,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT d from examples_ks.timestamps", &[])
         .await?
-        .into_typed::<(CqlTimestamp,)>();
+        .into_typed::<(CqlTimestamp,)>()?;
     while let Some((read_time,)) = iter.try_next().await? {
         println!("Read a timestamp as raw millis: {:?}", read_time);
     }

examples/cqlsh-rs.rs

@@ -3,8 +3,11 @@ use rustyline::completion::{Completer, Pair};
 use rustyline::error::ReadlineError;
 use rustyline::{CompletionType, Config, Context, Editor};
 use rustyline_derive::{Helper, Highlighter, Hinter, Validator};
+use scylla::transport::session::Session;
 use scylla::transport::Compression;
-use scylla::{QueryResult, Session, SessionBuilder};
+use scylla::QueryRowsResult;
+use scylla::SessionBuilder;
+use scylla_cql::frame::response::result::Row;
 use std::env;
 
 #[derive(Helper, Highlighter, Validator, Hinter)]
@@ -173,23 +176,24 @@ impl Completer for CqlHelper {
     }
 }
 
-fn print_result(result: &QueryResult) {
-    if result.rows.is_none() {
-        println!("OK");
-        return;
-    }
-    for row in result.rows.as_ref().unwrap() {
-        for column in &row.columns {
-            print!("|");
-            print!(
-                " {:16}",
-                match column {
-                    None => "null".to_owned(),
-                    Some(value) => format!("{:?}", value),
-                }
-            );
+fn print_result(result: Option<&QueryRowsResult>) {
+    if let Some(rows_result) = result {
+        for row in rows_result.rows::<Row>().unwrap() {
+            let row = row.unwrap();
+            for column in &row.columns {
+                print!("|");
+                print!(
+                    " {:16}",
+                    match column {
+                        None => "null".to_owned(),
+                        Some(value) => format!("{:?}", value),
+                    }
+                );
+            }
+            println!("|")
         }
-        println!("|")
+    } else {
+        println!("OK");
     }
 }
 
@@ -222,7 +226,10 @@ async fn main() -> Result<()> {
                 let maybe_res = session.query_unpaged(line, &[]).await;
                 match maybe_res {
                     Err(err) => println!("Error: {}", err),
-                    Ok(res) => print_result(&res),
+                    Ok(res) => {
+                        let rows_res = res.into_rows_result()?;
+                        print_result(rows_res.as_ref())
+                    }
                 }
             }
             Err(ReadlineError::Interrupted) => continue,

examples/custom_deserialization.rs

@@ -2,7 +2,8 @@ use anyhow::Result;
 use scylla::cql_to_rust::{FromCqlVal, FromCqlValError};
 use scylla::frame::response::result::CqlValue;
 use scylla::macros::impl_from_cql_value_from_method;
-use scylla::{Session, SessionBuilder};
+use scylla::transport::session::Session;
+use scylla::SessionBuilder;
 use std::env;
 
 #[tokio::main]
@@ -46,6 +47,7 @@ async fn main() -> Result<()> {
             (),
         )
         .await?
+        .into_legacy_result()?
         .single_row_typed::<(MyType,)>()?;
     assert_eq!(v, MyType("asdf".to_owned()));
 
@@ -73,6 +75,7 @@ async fn main() -> Result<()> {
             (),
         )
         .await?
+        .into_legacy_result()?
         .single_row_typed::<(MyOtherType,)>()?;
     assert_eq!(v, MyOtherType("asdf".to_owned()));
 

examples/get_by_name.rs

@@ -1,6 +1,7 @@
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, Context as _, Result};
 use scylla::transport::session::Session;
 use scylla::SessionBuilder;
+use scylla_cql::frame::response::result::Row;
 use std::env;
 
 #[tokio::main]
@@ -35,18 +36,26 @@ async fn main() -> Result<()> {
         )
         .await?;
 
-    let query_result = session
+    let rows_result = session
         .query_unpaged("SELECT pk, ck, value FROM examples_ks.get_by_name", &[])
-        .await?;
-    let (ck_idx, _) = query_result
-        .get_column_spec("ck")
+        .await?
+        .into_rows_result()?
+        .context("Response is not of Rows type")?;
+    let col_specs = rows_result.column_specs();
+    let (ck_idx, _) = col_specs
+        .get_by_name("ck")
         .ok_or_else(|| anyhow!("No ck column found"))?;
-    let (value_idx, _) = query_result
-        .get_column_spec("value")
+    let (value_idx, _) = col_specs
+        .get_by_name("value")
         .ok_or_else(|| anyhow!("No value column found"))?;
+    let rows = rows_result
+        .rows::<Row>()
+        .unwrap()
+        .collect::<Result<Vec<_>, _>>()
+        .unwrap();
     println!("ck           |  value");
     println!("---------------------");
-    for row in query_result.rows.ok_or_else(|| anyhow!("no rows found"))? {
+    for row in rows {
         println!("{:?} | {:?}", row.columns[ck_idx], row.columns[value_idx]);
     }
 

examples/logging_log.rs

@@ -1,6 +1,5 @@
 use anyhow::Result;
-use scylla::transport::session::Session;
-use scylla::SessionBuilder;
+use scylla::{Session, SessionBuilder};
 use std::env;
 use tracing::info;
 

examples/query_history.rs

@@ -1,7 +1,6 @@
 //! This example shows how to collect history of query execution.
 
 use anyhow::Result;
-use futures::StreamExt;
 use scylla::history::{HistoryCollector, StructuredHistory};
 use scylla::query::Query;
 use scylla::transport::session::Session;

examples/schema_agreement.rs

@@ -1,5 +1,4 @@
 use anyhow::{bail, Result};
-use futures::TryStreamExt;
 use scylla::transport::errors::QueryError;
 use scylla::transport::session::Session;
 use scylla::SessionBuilder;
@@ -70,7 +69,7 @@ async fn main() -> Result<()> {
     let mut iter = session
         .query_iter("SELECT a, b, c FROM examples_ks.schema_agreement", &[])
         .await?
-        .into_typed::<(i32, i32, String)>();
+        .into_typed::<(i32, i32, String)>()?;
     while let Some((a, b, c)) = iter.try_next().await? {
         println!("a, b, c: {}, {}, {}", a, b, c);
     }

examples/select-paging.rs

@@ -1,5 +1,4 @@
 use anyhow::Result;
-use futures::stream::StreamExt;
 use scylla::statement::PagingState;
 use scylla::{query::Query, Session, SessionBuilder};
 use std::env;
@@ -35,7 +34,7 @@ async fn main() -> Result<()> {
     let mut rows_stream = session
         .query_iter("SELECT a, b, c FROM examples_ks.select_paging", &[])
         .await?
-        .into_typed::<(i32, i32, String)>();
+        .into_typed::<(i32, i32, String)>()?;
 
     while let Some(next_row_res) = rows_stream.next().await {
         let (a, b, c) = next_row_res?;
@@ -51,10 +50,14 @@ async fn main() -> Result<()> {
             .query_single_page(paged_query.clone(), &[], paging_state)
             .await?;
 
+        let res = res
+            .into_rows_result()?
+            .expect("Got result different than Rows");
+
         println!(
             "Paging state: {:#?} ({} rows)",
             paging_state_response,
-            res.rows_num()?,
+            res.rows_num(),
         );
 
         match paging_state_response.into_paging_control_flow() {
@@ -81,10 +84,14 @@ async fn main() -> Result<()> {
             .execute_single_page(&paged_prepared, &[], paging_state)
             .await?;
 
+        let res = res
+            .into_rows_result()?
+            .expect("Got result different than Rows");
+
         println!(
             "Paging state from the prepared statement execution: {:#?} ({} rows)",
             paging_state_response,
-            res.rows_num()?,
+            res.rows_num(),
         );
 
         match paging_state_response.into_paging_control_flow() {