Custom timestamps as a per-execution setting

docs/source/connecting/compression.md

@@ -13,7 +13,7 @@ An example enabling `Snappy` compression algorithm:
 # extern crate scylla;
 # extern crate tokio;
 use scylla::{Session, SessionBuilder};
-use scylla::transport::Compression;
+use scylla::connection::Compression;
 use std::error::Error;
 
 #[tokio::main]

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

@@ -8,7 +8,7 @@ To create an `ExecutionProfile` and attach it as default for `Session`:
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
 use scylla::{Session, SessionBuilder};
 use scylla::statement::Consistency;
-use scylla::transport::ExecutionProfile;
+use scylla::execution::ExecutionProfile;
 
 let profile = ExecutionProfile::builder()
     .consistency(Consistency::LocalOne)
@@ -34,7 +34,7 @@ To create an `ExecutionProfile` and attach it to a `Query`:
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
 use scylla::query::Query;
 use scylla::statement::Consistency;
-use scylla::transport::ExecutionProfile;
+use scylla::execution::ExecutionProfile;
 use std::time::Duration;
 
 let profile = ExecutionProfile::builder()
@@ -60,7 +60,7 @@ To create an `ExecutionProfile` based on another profile:
 # use std::error::Error;
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
 use scylla::statement::Consistency;
-use scylla::transport::ExecutionProfile;
+use scylla::execution::ExecutionProfile;
 use std::time::Duration;
 
 let base_profile = ExecutionProfile::builder()

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

@@ -9,9 +9,9 @@
 use scylla::query::Query;
 use scylla::speculative_execution::SimpleSpeculativeExecutionPolicy;
 use scylla::statement::{Consistency, SerialConsistency};
-use scylla::transport::ExecutionProfile;
-use scylla::transport::load_balancing::DefaultPolicy;
-use scylla::transport::retry_policy::FallthroughRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::load_balancing::DefaultPolicy;
+use scylla::execution::retries::FallthroughRetryPolicy;
 use std::{sync::Arc, time::Duration};
 
 let profile = ExecutionProfile::builder()

docs/source/execution-profiles/priority.md

@@ -16,7 +16,7 @@ Priorities of execution profiles and directly set options:
 use scylla::{Session, SessionBuilder};
 use scylla::query::Query;
 use scylla::statement::Consistency;
-use scylla::transport::ExecutionProfile;
+use scylla::execution::ExecutionProfile;
 
 let session_profile = ExecutionProfile::builder()
     .consistency(Consistency::One)

docs/source/execution-profiles/remap.md

@@ -26,7 +26,7 @@ Below, the remaps described above are followed in code.
 use scylla::{Session, SessionBuilder};
 use scylla::query::Query;
 use scylla::statement::Consistency;
-use scylla::transport::ExecutionProfile;
+use scylla::execution::ExecutionProfile;
 
 let profile1 = ExecutionProfile::builder()
     .consistency(Consistency::One)

docs/source/load-balancing/load-balancing.md

@@ -9,7 +9,7 @@ balancing plan based on the query information and the state of the cluster.
 
 Load balancing policies do not influence to which nodes connections are
 being opened. For a node connection blacklist configuration refer to
-`scylla::transport::host_filter::HostFilter`, which can be set session-wide
+`scylla::cluster::host_filter::HostFilter`, which can be set session-wide
 using `SessionBuilder::host_filter` method.
 
 In this chapter, "target" will refer to a pair `<node, optional shard>`.
@@ -51,8 +51,8 @@ The newly created execution profile is then converted to a handle using
 # async fn check_only_compiles(uri: &str) -> Result<(), Box<dyn Error>> {
 use scylla::SessionBuilder;
 use scylla::load_balancing::DefaultPolicy;
-use scylla::transport::ExecutionProfile;
-use scylla::transport::session::Session;
+use scylla::execution::ExecutionProfile;
+use scylla::session::Session;
 use std::sync::Arc;
 
 let policy = Arc::new(DefaultPolicy::default());

docs/source/migration-guides/0.15-deserialization.md

@@ -285,7 +285,7 @@ let legacy_result: LegacyQueryResult = result.into_legacy_result()?;
 
 ```rust
 # extern crate scylla;
-# use scylla::transport::iterator::{QueryPager, LegacyRowIterator};
+# use scylla::execution::pager::{QueryPager, LegacyRowIterator};
 # use std::error::Error;
 # async fn check_only_compiles(pager: QueryPager) -> Result<(), Box<dyn Error>> {
 let pager: QueryPager = pager;

docs/source/queries/result.md

@@ -21,16 +21,16 @@ return a `QueryResult` with rows represented as `Option<Vec<Row>>`.
 
 ## Parsing using convenience methods
 
-By calling [`QueryResult::into_rows_result`](https://docs.rs/scylla/latest/scylla/transport/query_result/struct.QueryResult.html#method.into_rows_result),
-one can obtain  [`QueryRowsResult`](https://docs.rs/scylla/latest/scylla/transport/query_result/struct.QueryRowsResult.html).
+By calling [`QueryResult::into_rows_result`](https://docs.rs/scylla/latest/scylla/response/query_result/struct.QueryResult.html#method.into_rows_result),
+one can obtain  [`QueryRowsResult`](https://docs.rs/scylla/latest/scylla/response/query_result/struct.QueryRowsResult.html).
 `QueryRowsResult` provides convenience methods for parsing rows.
 Here are a few of them:
 * `rows::<RowT>()` - returns the rows parsed as the given type
 * `maybe_first_row::<RowT>()` - returns the first received row or `None` if there are no rows
 * `first_row::<RowT>()` - returns the first received row; fails if there are no rows
 * `single_row::<RowT>()` - same as `first_row`, but fails when there is more than one row
 
-Additionally, [`QueryResult`](https://docs.rs/scylla/latest/scylla/transport/query_result/struct.QueryResult.html) has a method `result_not_rows()`, which ensures that query response was not `rows` and thus helps avoid bugs.
+Additionally, [`QueryResult`](https://docs.rs/scylla/latest/scylla/response/query_result/struct.QueryResult.html) has a method `result_not_rows()`, which ensures that query response was not `rows` and thus helps avoid bugs.
 
 ```rust
 # extern crate scylla;
@@ -59,8 +59,8 @@ session.query_unpaged("INSERT INTO ks.tab (a) VALUES (0)", &[]).await?.result_no
 # Ok(())
 # }
 ```
-For more see [`QueryResult`](https://docs.rs/scylla/latest/scylla/transport/query_result/struct.QueryResult.html)
-and [`QueryRowsResult`](https://docs.rs/scylla/latest/scylla/transport/query_result/struct.QueryRowsResult.html)
+For more see [`QueryResult`](https://docs.rs/scylla/latest/scylla/response/query_result/struct.QueryResult.html)
+and [`QueryRowsResult`](https://docs.rs/scylla/latest/scylla/response/query_result/struct.QueryRowsResult.html)
 
 ### `NULL` values
 `NULL` values will return an error when parsed as a Rust type. 

docs/source/queries/timeouts.md

@@ -18,7 +18,7 @@ However, setting per-statement timeout to `None` results in falling back to per-
 # use std::error::Error;
 # async fn timeouts() -> Result<(), Box<dyn Error>> {
 use scylla::{Session, SessionBuilder, query::Query};
-use scylla::transport::ExecutionProfile;
+use scylla::execution::ExecutionProfile;
 use std::time::Duration;
 
 let uri = std::env::var("SCYLLA_URI")

docs/source/retry-policy/default.md

@@ -12,8 +12,8 @@ To use in `Session`:
 # use std::sync::Arc;
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
 use scylla::{Session, SessionBuilder};
-use scylla::transport::ExecutionProfile;
-use scylla::transport::retry_policy::DefaultRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::retries::DefaultRetryPolicy;
 
 let handle = ExecutionProfile::builder()
     .retry_policy(Arc::new(DefaultRetryPolicy::new()))
@@ -37,8 +37,8 @@ To use in a [simple query](../queries/simple.md):
 # use std::sync::Arc;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::query::Query;
-use scylla::transport::ExecutionProfile;
-use scylla::transport::retry_policy::DefaultRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::retries::DefaultRetryPolicy;
 
 // Create a Query manually and set the retry policy
 let mut my_query: Query = Query::new("INSERT INTO ks.tab (a) VALUES(?)");
@@ -66,8 +66,8 @@ To use in a [prepared query](../queries/prepared.md):
 # use std::sync::Arc;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::prepared_statement::PreparedStatement;
-use scylla::transport::ExecutionProfile;
-use scylla::transport::retry_policy::DefaultRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::retries::DefaultRetryPolicy;
 
 // Create PreparedStatement manually and set the retry policy
 let mut prepared: PreparedStatement = session

docs/source/retry-policy/downgrading-consistency.md

@@ -53,8 +53,8 @@ To use in `Session`:
 # use std::sync::Arc;
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
 use scylla::{Session, SessionBuilder};
-use scylla::transport::ExecutionProfile;
-use scylla::transport::downgrading_consistency_retry_policy::DowngradingConsistencyRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::retries::DowngradingConsistencyRetryPolicy;
 
 let handle = ExecutionProfile::builder()
     .retry_policy(Arc::new(DowngradingConsistencyRetryPolicy::new()))
@@ -78,8 +78,8 @@ To use in a [simple query](../queries/simple.md):
 # use std::sync::Arc;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::query::Query;
-use scylla::transport::ExecutionProfile;
-use scylla::transport::downgrading_consistency_retry_policy::DowngradingConsistencyRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::retries::DowngradingConsistencyRetryPolicy;
 
 let handle = ExecutionProfile::builder()
     .retry_policy(Arc::new(DowngradingConsistencyRetryPolicy::new()))
@@ -105,8 +105,8 @@ To use in a [prepared query](../queries/prepared.md):
 # use std::sync::Arc;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::prepared_statement::PreparedStatement;
-use scylla::transport::ExecutionProfile;
-use scylla::transport::downgrading_consistency_retry_policy::DowngradingConsistencyRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::retries::DowngradingConsistencyRetryPolicy;
 
 let handle = ExecutionProfile::builder()
     .retry_policy(Arc::new(DowngradingConsistencyRetryPolicy::new()))

docs/source/retry-policy/fallthrough.md

@@ -11,8 +11,8 @@ To use in `Session`:
 # use std::sync::Arc;
 # async fn check_only_compiles() -> Result<(), Box<dyn Error>> {
 use scylla::{Session, SessionBuilder};
-use scylla::transport::ExecutionProfile;
-use scylla::transport::retry_policy::FallthroughRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::retries::FallthroughRetryPolicy;
 
 let handle = ExecutionProfile::builder()
     .retry_policy(Arc::new(FallthroughRetryPolicy::new()))
@@ -36,8 +36,8 @@ To use in a [simple query](../queries/simple.md):
 # use std::sync::Arc;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::query::Query;
-use scylla::transport::ExecutionProfile;
-use scylla::transport::retry_policy::FallthroughRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::retries::FallthroughRetryPolicy;
 
 let handle = ExecutionProfile::builder()
     .retry_policy(Arc::new(FallthroughRetryPolicy::new()))
@@ -63,8 +63,8 @@ To use in a [prepared query](../queries/prepared.md):
 # use std::sync::Arc;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::prepared_statement::PreparedStatement;
-use scylla::transport::ExecutionProfile;
-use scylla::transport::retry_policy::FallthroughRetryPolicy;
+use scylla::execution::ExecutionProfile;
+use scylla::execution::retries::FallthroughRetryPolicy;
 
 let handle = ExecutionProfile::builder()
     .retry_policy(Arc::new(FallthroughRetryPolicy::new()))

docs/source/speculative-execution/percentile.md

@@ -17,7 +17,7 @@ use scylla::{
     Session,
     SessionBuilder,
     speculative_execution::PercentileSpeculativeExecutionPolicy,
-    transport::execution_profile::ExecutionProfile,
+    execution::execution_profile::ExecutionProfile,
 };
 
 let policy = PercentileSpeculativeExecutionPolicy  {

docs/source/speculative-execution/simple.md

@@ -17,7 +17,7 @@ use scylla::{
     Session,
     SessionBuilder,
     speculative_execution::SimpleSpeculativeExecutionPolicy,
-    transport::execution_profile::ExecutionProfile,
+    execution::execution_profile::ExecutionProfile,
 };
 
 let policy = SimpleSpeculativeExecutionPolicy {

docs/source/tracing/basic.md

@@ -12,7 +12,7 @@ return a `QueryResult` which contains a `tracing_id` if tracing was enabled.
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::query::Query;
 use scylla::QueryResult;
-use scylla::tracing::TracingInfo;
+use scylla::execution::tracing::TracingInfo;
 use uuid::Uuid;
 
 // Create a Query manually and enable tracing
@@ -40,7 +40,7 @@ if let Some(id) = tracing_id {
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::prepared_statement::PreparedStatement;
 use scylla::QueryResult;
-use scylla::tracing::TracingInfo;
+use scylla::execution::tracing::TracingInfo;
 use uuid::Uuid;
 
 // Prepare the query
@@ -72,7 +72,7 @@ if let Some(id) = tracing_id {
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::batch::Batch;
 use scylla::QueryResult;
-use scylla::tracing::TracingInfo;
+use scylla::execution::tracing::TracingInfo;
 use uuid::Uuid;
 
 // Create a batch statement

docs/source/tracing/paged.md

@@ -13,7 +13,7 @@ If tracing is enabled the row iterator will contain a list of tracing ids for al
 # use std::error::Error;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::query::Query;
-use scylla::tracing::TracingInfo;
+use scylla::execution::tracing::TracingInfo;
 use futures::StreamExt;
 use uuid::Uuid;
 
@@ -51,7 +51,7 @@ for id in tracing_ids {
 # use std::error::Error;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::prepared_statement::PreparedStatement;
-use scylla::tracing::TracingInfo;
+use scylla::execution::tracing::TracingInfo;
 use futures::StreamExt;
 use uuid::Uuid;
 

docs/source/tracing/prepare.md

@@ -10,7 +10,7 @@
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::query::Query;
 use scylla::prepared_statement::PreparedStatement;
-use scylla::tracing::TracingInfo;
+use scylla::execution::tracing::TracingInfo;
 use uuid::Uuid;
 
 // Prepare the query with tracing enabled

docs/source/tracing/query-history.md

@@ -12,7 +12,7 @@ This history includes all requests sent, decisions to retry and speculative exec
 # use std::error::Error;
 # async fn check_only_compiles(session: &Session) -> Result<(), Box<dyn Error>> {
 use scylla::query::Query;
-use scylla::history::{HistoryCollector, StructuredHistory};
+use scylla::execution::history::{HistoryCollector, StructuredHistory};
 use std::sync::Arc;
 
 // Create a query for which we would like to trace the history of its execution

examples/allocations.rs

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

examples/basic.rs

@@ -2,7 +2,7 @@ use anyhow::Result;
 use futures::StreamExt as _;
 use futures::TryStreamExt as _;
 use scylla::frame::response::result::Row;
-use scylla::transport::session::Session;
+use scylla::session::Session;
 use scylla::DeserializeRow;
 use scylla::SessionBuilder;
 use std::env;

examples/compare-tokens.rs

@@ -1,6 +1,6 @@
 use anyhow::Result;
+use scylla::cluster::NodeAddr;
 use scylla::routing::Token;
-use scylla::transport::NodeAddr;
 use scylla::{Session, SessionBuilder};
 use std::env;
 

examples/cql-time-types.rs

@@ -6,7 +6,7 @@ use chrono::{DateTime, NaiveDate, NaiveTime, Utc};
 use futures::{StreamExt as _, TryStreamExt as _};
 use scylla::frame::response::result::CqlValue;
 use scylla::frame::value::{CqlDate, CqlTime, CqlTimestamp};
-use scylla::transport::session::Session;
+use scylla::session::Session;
 use scylla::SessionBuilder;
 use std::env;
 

examples/cqlsh-rs.rs

@@ -3,10 +3,10 @@ use rustyline::completion::{Completer, Pair};
 use rustyline::error::ReadlineError;
 use rustyline::{CompletionType, Config, Context, Editor};
 use rustyline_derive::{Helper, Highlighter, Hinter, Validator};
+use scylla::connection::Compression;
 use scylla::frame::response::result::Row;
-use scylla::transport::query_result::IntoRowsResultError;
-use scylla::transport::session::Session;
-use scylla::transport::Compression;
+use scylla::response::query_result::IntoRowsResultError;
+use scylla::session::Session;
 use scylla::QueryResult;
 use scylla::SessionBuilder;
 use std::env;

examples/custom_deserialization.rs

@@ -1,7 +1,7 @@
 use anyhow::Result;
 use scylla::deserialize::DeserializeValue;
 use scylla::frame::response::result::ColumnType;
-use scylla::transport::session::Session;
+use scylla::session::Session;
 use scylla::SessionBuilder;
 use std::env;
 

examples/custom_load_balancing_policy.rs

@@ -1,11 +1,12 @@
 use anyhow::Result;
 use rand::thread_rng;
 use rand::Rng;
-use scylla::transport::NodeRef;
+use scylla::cluster::NodeRef;
 use scylla::{
+    cluster::ClusterData,
+    execution::ExecutionProfile,
     load_balancing::{LoadBalancingPolicy, RoutingInfo},
     routing::Shard,
-    transport::{ClusterData, ExecutionProfile},
     Session, SessionBuilder,
 };
 use std::{env, sync::Arc};