Struct BlockingSession 

pub struct BlockingSession { /* private fields */ }

A blocking session that waits for responses synchronously

Implementations

impl BlockingSession

pub fn command( &mut self, rql: &str, params: Option<Params>, ) -> Result<CommandResult, Error>

Send a command and wait for response

Examples found in repository

examples/blocking_ws.rs (line 16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
	// Connect to ReifyDB server - various ways to specify address:
	// Using tuple (address, port):
	let client = Client::ws(("127.0.0.1", 8090))?;

	// Create a blocking session with authentication
	let mut session = client.blocking_session(Some("mysecrettoken".to_string()))?;

	// Execute a command to create a table
	let command_result =
		session.command("CREATE NAMESPACE test; CREATE TABLE test.users { id: INT4, name: UTF8 }", None)?;
	println!("Command executed: {} frames returned", command_result.frames.len());

	// Execute a query
	let query_result = session.query("MAP { x: 42, y: 'hello' }", None)?;

	println!("Query executed: {} frames returned", query_result.frames.len());

	// Print first frame if available
	if let Some(frame) = query_result.frames.first() {
		println!("First frame:\n{}", frame);
	}

	Ok(())
}

pub fn query( &mut self, rql: &str, params: Option<Params>, ) -> Result<QueryResult, Error>

Send a query and wait for response

Examples found in repository

examples/blocking_ws.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
	// Connect to ReifyDB server - various ways to specify address:
	// Using tuple (address, port):
	let client = Client::ws(("127.0.0.1", 8090))?;

	// Create a blocking session with authentication
	let mut session = client.blocking_session(Some("mysecrettoken".to_string()))?;

	// Execute a command to create a table
	let command_result =
		session.command("CREATE NAMESPACE test; CREATE TABLE test.users { id: INT4, name: UTF8 }", None)?;
	println!("Command executed: {} frames returned", command_result.frames.len());

	// Execute a query
	let query_result = session.query("MAP { x: 42, y: 'hello' }", None)?;

	println!("Query executed: {} frames returned", query_result.frames.len());

	// Print first frame if available
	if let Some(frame) = query_result.frames.first() {
		println!("First frame:\n{}", frame);
	}

	Ok(())
}

examples/test_remote_sort.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
	println!("Connecting to ws://192.168.100.52:8090/\n");

	// Connect to the remote server
	let client = Client::ws(("192.168.100.52", 8090))?;

	// Try with auth token from environment or use "root"
	let token = std::env::var("REIFYDB_TOKEN").unwrap_or_else(|_| "root".to_string());
	println!(
		"Using auth token: {}\n",
		if token == "root" {
			"root (default)"
		} else {
			&token
		}
	);

	// Create a blocking session with auth token
	let mut session = client.blocking_session(Some(token))?;

	println!("Connected successfully!\n");

	// Test ASC
	println!("=== TEST 1: ASC (should show smallest first) ===");
	println!("Query:");
	println!("from system.table_storage_stats");
	println!("sort total_bytes asc\n");

	let query_asc = "from system.table_storage_stats\nsort total_bytes asc";
	let result_asc = session.query(query_asc, None)?;

	if let Some(frame) = result_asc.frames.first() {
		if let Some(total_bytes_col) = frame.columns.iter().find(|c| c.name == "total_bytes") {
			let mut values: Vec<u64> = Vec::new();
			for i in 0..total_bytes_col.data.len() {
				let val = total_bytes_col.data.as_string(i).parse::<u64>().unwrap_or(0);
				values.push(val);
			}
			println!("ASC Results: {:?}", values);
			println!("First value (should be smallest): {}", values[0]);
			println!("Last value (should be largest): {}\n", values[values.len() - 1]);
		}
	}

	// Test DESC
	println!("=== TEST 2: DESC (should show largest first) ===");
	println!("Query:");
	println!("from system.table_storage_stats");
	println!("sort total_bytes desc\n");

	let query = "from system.table_storage_stats\nsort total_bytes desc";
	let result = session.query(query, None)?;

	println!("Query executed: {} frames returned\n", result.frames.len());

	// Print the results
	if let Some(frame) = result.frames.first() {
		println!("Frame output:");
		println!("{}\n", frame);

		// Also analyze the data
		if let Some(total_bytes_col) = frame.columns.iter().find(|c| c.name == "total_bytes") {
			println!("=== Analyzing total_bytes column ===");
			let mut values: Vec<u64> = Vec::new();
			for i in 0..total_bytes_col.data.len() {
				let val = total_bytes_col.data.as_string(i).parse::<u64>().unwrap_or(0);
				values.push(val);
				println!("Row {}: {} bytes", i, val);
			}

			println!("\nValues in order: {:?}", values);

			// Check if sorted correctly (DESC = largest first)
			let mut is_desc_sorted = true;
			for i in 1..values.len() {
				if values[i - 1] < values[i] {
					is_desc_sorted = false;
					println!(
						"\n⚠️  SORTING ERROR at position {}: {} < {}",
						i,
						values[i - 1],
						values[i]
					);
				}
			}

			if is_desc_sorted {
				println!("\n✅ Correctly sorted in DESCENDING order (largest first)");
			} else {
				println!("\n❌ NOT correctly sorted in descending order!");
				println!("   Expected: Largest value first, decreasing values");
				println!("   Got: {:?}", values);
			}
		}
	}

	Ok(())
}

pub fn is_authenticated(&self) -> bool

Check if the session is authenticated