statement: rename Query -> Statement

Author: muzarski

docs/source/execution-profiles/create-and-use.md

@@ -33,7 +33,7 @@ To create an `ExecutionProfile` and attach it to a `Query`:
 # extern crate scylla;
 # use std::error::Error;
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use scylla::statement::Consistency;
 use scylla::client::execution_profile::ExecutionProfile;
 use std::time::Duration;
@@ -45,10 +45,10 @@ let profile = ExecutionProfile::builder()
 
 let handle = profile.into_handle();
 
-let mut query1 = Query::from("SELECT * FROM ks.table");
+let mut query1 = Statement::from("SELECT * FROM ks.table");
 query1.set_execution_profile_handle(Some(handle.clone()));
 
-let mut query2 = Query::from("SELECT pk FROM ks.table WHERE pk = ?");
+let mut query2 = Statement::from("SELECT pk FROM ks.table WHERE pk = ?");
 query2.set_execution_profile_handle(Some(handle));
 # Ok(())
 # }

docs/source/execution-profiles/maximal-example.md

@@ -6,7 +6,7 @@
 # extern crate scylla;
 # use std::error::Error;
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use scylla::policies::speculative_execution::SimpleSpeculativeExecutionPolicy;
 use scylla::statement::{Consistency, SerialConsistency};
 use scylla::client::execution_profile::ExecutionProfile;
@@ -32,7 +32,7 @@ let profile = ExecutionProfile::builder()
     )
     .build();
 
-let mut query = Query::from("SELECT * FROM ks.table");
+let mut query = Statement::from("SELECT * FROM ks.table");
 query.set_execution_profile_handle(Some(profile.into_handle()));
 
 # Ok(())

docs/source/execution-profiles/priority.md

@@ -15,7 +15,7 @@ Priorities of execution profiles and directly set options:
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
 use scylla::client::session::Session;
 use scylla::client::session_builder::SessionBuilder;
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use scylla::statement::Consistency;
 use scylla::client::execution_profile::ExecutionProfile;
 
@@ -33,7 +33,7 @@ let session: Session = SessionBuilder::new()
     .build()
     .await?;
 
-let mut query = Query::from("SELECT * FROM ks.table");
+let mut query = Statement::from("SELECT * FROM ks.table");
 
 // Query is not assigned any specific profile, so session's profile is applied.
 // Therefore, the query will be executed with Consistency::One.

docs/source/execution-profiles/remap.md

@@ -25,7 +25,7 @@ Below, the remaps described above are followed in code.
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
 use scylla::client::session::Session;
 use scylla::client::session_builder::SessionBuilder;
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use scylla::statement::Consistency;
 use scylla::client::execution_profile::ExecutionProfile;
 
@@ -46,8 +46,8 @@ let session: Session = SessionBuilder::new()
     .build()
     .await?;
 
-let mut query1 = Query::from("SELECT * FROM ks.table");
-let mut query2 = Query::from("SELECT pk FROM ks.table WHERE pk = ?");
+let mut query1 = Statement::from("SELECT * FROM ks.table");
+let mut query2 = Statement::from("SELECT pk FROM ks.table WHERE pk = ?");
 
 query1.set_execution_profile_handle(Some(handle1.clone()));
 query2.set_execution_profile_handle(Some(handle2.clone()));

docs/source/queries/batch.md

@@ -10,7 +10,7 @@ Only `INSERT`, `UPDATE` and `DELETE` statements are allowed.
 # use std::error::Error;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::statement::batch::Batch;
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use scylla::statement::prepared::PreparedStatement;
 
 // Create a batch statement
@@ -20,7 +20,7 @@ let mut batch: Batch = Default::default();
 batch.append_statement("INSERT INTO ks.tab(a, b) VALUES(1, 2)");
 
 // Add a simple statement created manually to the batch
-let simple: Query = Query::new("INSERT INTO ks.tab (a, b) VALUES(3, 4)");
+let simple: Statement = Statement::new("INSERT INTO ks.tab (a, b) VALUES(3, 4)");
 batch.append_statement(simple);
 
 // Add a prepared statement to the batch

docs/source/queries/lwt.md

@@ -10,11 +10,11 @@ A lightweight transaction query is not a separate type - it can be expressed jus
 # use scylla::client::session::Session;
 # use std::error::Error;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use scylla::statement::{Consistency, SerialConsistency};
 
 // Create a Query manually to change the Consistency to ONE
-let mut my_query: Query = Query::new("INSERT INTO ks.tab (a) VALUES(?) IF NOT EXISTS".to_string());
+let mut my_query: Statement = Statement::new("INSERT INTO ks.tab (a) VALUES(?) IF NOT EXISTS".to_string());
 my_query.set_consistency(Consistency::One);
 // Use cross-datacenter serial consistency
 my_query.set_serial_consistency(Some(SerialConsistency::Serial));

docs/source/queries/paged.md

@@ -105,9 +105,9 @@ On a `Query`:
 # use scylla::client::session::Session;
 # use std::error::Error;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 
-let mut query: Query = Query::new("SELECT a, b FROM ks.t");
+let mut query: Statement = Statement::new("SELECT a, b FROM ks.t");
 query.set_page_size(16);
 
 let _ = session.query_iter(query, &[]).await?; // ...
@@ -145,11 +145,11 @@ On a `Query`:
 # use scylla::client::session::Session;
 # use std::error::Error;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use scylla::response::{PagingState, PagingStateResponse};
 use std::ops::ControlFlow;
 
-let paged_query = Query::new("SELECT a, b, c FROM ks.t").with_page_size(6);
+let paged_query = Statement::new("SELECT a, b, c FROM ks.t").with_page_size(6);
 
 let mut paging_state = PagingState::start();
 loop {
@@ -188,12 +188,12 @@ On a `PreparedStatement`:
 # use scylla::client::session::Session;
 # use std::error::Error;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use scylla::response::{PagingState, PagingStateResponse};
 use std::ops::ControlFlow;
 
 let paged_prepared = session
-    .prepare(Query::new("SELECT a, b, c FROM ks.t").with_page_size(7))
+    .prepare(Statement::new("SELECT a, b, c FROM ks.t").with_page_size(7))
     .await?;
 
 let mut paging_state = PagingState::start();

docs/source/queries/simple.md

@@ -36,11 +36,11 @@ You can create a query manually to set custom options. For example to change que
 # use scylla::client::session::Session;
 # use std::error::Error;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use scylla::statement::Consistency;
 
 // Create a Query manually to change the Consistency to ONE
-let mut my_query: Query = Query::new("INSERT INTO ks.tab (a) VALUES(?)");
+let mut my_query: Statement = Statement::new("INSERT INTO ks.tab (a) VALUES(?)");
 my_query.set_consistency(Consistency::One);
 
 // Insert a value into the table

docs/source/queries/timeouts.md

@@ -20,7 +20,7 @@ However, setting per-statement timeout to `None` results in falling back to per-
 use scylla::client::execution_profile::ExecutionProfile;
 use scylla::client::session::Session;
 use scylla::client::session_builder::SessionBuilder;
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use std::time::Duration;
 
 let uri = std::env::var("SCYLLA_URI")
@@ -49,7 +49,7 @@ let three_sec_timeout_profile_handle = ExecutionProfile::builder()
 
 // The below query will last for no more than 3 seconds, yielding a RequestTimeout error
 // if no response arrives until then.
-let mut query: Query = "TRUNCATE keyspace.table".into();
+let mut query: Statement = "TRUNCATE keyspace.table".into();
 query.set_execution_profile_handle(Some(three_sec_timeout_profile_handle));
 session
     .query_unpaged(query, ())

docs/source/queries/timestamp-generators.md

@@ -33,7 +33,7 @@ be warned about the clock skew, the warnings can be turned off with `without_war
 use scylla::client::session::Session;
 use scylla::client::session_builder::SessionBuilder;
 use scylla::policies::timestamp_generator::MonotonicTimestampGenerator;
-use scylla::statement::query::Query;
+use scylla::statement::query::Statement;
 use std::sync::Arc;
 
 let session: Session = SessionBuilder::new()
@@ -44,7 +44,7 @@ let session: Session = SessionBuilder::new()
 
 // This query will have a timestamp generated 
 // by the monotonic timestamp generator
-let my_query: Query = Query::new("INSERT INTO ks.tab (a) VALUES(?)");
+let my_query: Statement = Statement::new("INSERT INTO ks.tab (a) VALUES(?)");
 let to_insert: i32 = 12345;
 session.query_unpaged(my_query, (to_insert,)).await?;
 # Ok(())