Statement (Unprepared)

pub struct Statement {
    pub contents: String,
    // ... internal fields
}

pub fn new(query_text: impl Into<String>) -> Self

use scylla::statement::Statement;

let stmt = Statement::new("SELECT * FROM users WHERE id = ?");

pub fn set_page_size(&mut self, page_size: i32)

pub fn with_page_size(self, page_size: i32) -> Self

pub fn get_page_size(&self) -> i32

pub fn set_consistency(&mut self, c: Consistency)

pub fn unset_consistency(&mut self)

pub fn get_consistency(&self) -> Option<Consistency>

pub fn set_serial_consistency(&mut self, sc: Option<SerialConsistency>)

pub fn unset_serial_consistency(&mut self)

pub fn get_serial_consistency(&self) -> Option<SerialConsistency>

pub fn set_is_idempotent(&mut self, is_idempotent: bool)

pub fn get_is_idempotent(&self) -> bool

pub fn set_tracing(&mut self, should_trace: bool)

pub fn get_tracing(&self) -> bool

pub fn set_timestamp(&mut self, timestamp: Option<i64>)

pub fn get_timestamp(&self) -> Option<i64>

pub fn set_request_timeout(&mut self, timeout: Option<Duration>)

pub fn get_request_timeout(&self) -> Option<Duration>

pub fn set_retry_policy(&mut self, retry_policy: Option<Arc<dyn RetryPolicy>>)

pub fn get_retry_policy(&self) -> Option<&Arc<dyn RetryPolicy>>

pub fn set_load_balancing_policy(
    &mut self,
    load_balancing_policy: Option<Arc<dyn LoadBalancingPolicy>>
)

pub fn get_load_balancing_policy(&self) -> Option<&Arc<dyn LoadBalancingPolicy>>

pub fn set_execution_profile_handle(
    &mut self,
    profile_handle: Option<ExecutionProfileHandle>
)

pub fn get_execution_profile_handle(&self) -> Option<&ExecutionProfileHandle>

pub fn set_history_listener(&mut self, history_listener: Arc<dyn HistoryListener>)

pub fn remove_history_listener(&mut self) -> Option<Arc<dyn HistoryListener>>

impl From<String> for Statement

impl From<&str> for Statement

use scylla::{Session, SessionBuilder};
use scylla::statement::Statement;
use scylla::frame::types::Consistency;
use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let session = SessionBuilder::new()
        .known_node("127.0.0.1:9042")
        .build()
        .await?;

    // Create and configure a statement
    let mut stmt = Statement::new("SELECT * FROM my_keyspace.my_table");
    stmt.set_consistency(Consistency::Quorum);
    stmt.set_page_size(1000);
    stmt.set_is_idempotent(true);
    stmt.set_request_timeout(Some(Duration::from_secs(5)));

    // Execute the statement
    let result = session.query_unpaged(stmt, &[]).await?;
    println!("Query returned {} rows", result.rows_num()?);

    Ok(())
}