Struct WsClient 

pub struct WsClient { /* private fields */ }

WebSocket client implementation

Implementations

impl WsClient

pub fn from_url(url: &str) -> Result<Self, Box<dyn Error>>

Create a new WebSocket client from URL string

pub fn new<A: ToSocketAddrs>(addr: A) -> Result<Self, Box<dyn Error>>

Create a new WebSocket client

pub fn blocking_session( &self, token: Option<String>, ) -> Result<WsBlockingSession, Error>

Create a blocking session

Examples found in repository

examples/blocking_ws.rs (line 12)

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 22)

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 callback_session( &self, token: Option<String>, ) -> Result<WsCallbackSession, Error>

Create a callback-based session

Examples found in repository

examples/callback_ws.rs (line 13)

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

	// Create a callback session with authentication
	let session = client.callback_session(Some("mysecrettoken".to_string()))?;

	// Execute a command to create a table
	let command_id = session.command(
		"CREATE NAMESPACE test; CREATE TABLE test.users { id: INT4, name: UTF8 }",
		None,
		|result| match result {
			Ok(data) => println!("Command executed: {} frames returned", data.frames.len()),
			Err(e) => println!("Command failed: {}", e),
		},
	)?;
	println!("Command sent with ID: {}", command_id);

	// Execute a query
	let query_id = session.query("MAP { x: 42, y: 'hello' }", None, |result| {
		match result {
			Ok(data) => {
				println!("Query executed: {} frames returned", data.frames.len());
				// Print first frame if available
				if let Some(frame) = data.frames.first() {
					println!("First frame:\n{}", frame);
				}
			}
			Err(e) => println!("Query failed: {}", e),
		}
	})?;
	println!("Query sent with ID: {}", query_id);

	// Wait for callbacks to complete
	thread::sleep(Duration::from_millis(500));

	Ok(())
}

pub fn channel_session( &self, token: Option<String>, ) -> Result<(WsChannelSession, Receiver<ResponseMessage>), Error>

Create a channel-based session

Examples found in repository

examples/channel_ws.rs (line 13)

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

	// Create a channel session with authentication
	let (session, receiver) = client.channel_session(Some("mysecrettoken".to_string()))?;

	// Consume authentication response
	if let Ok(msg) = receiver.recv_timeout(Duration::from_millis(100)) {
		if let Ok(ChannelResponse::Auth {
			request_id,
		}) = msg.response
		{
			println!("Authenticated with ID: {}", request_id);
		}
	}

	// Execute a command to create a table
	let command_id =
		session.command("CREATE NAMESPACE test; CREATE TABLE test.users { id: INT4, name: UTF8 }", None)?;
	println!("Command sent with ID: {}", command_id);

	// Execute a query
	let query_id = session.query("MAP { x: 42, y: 'hello' }", None)?;
	println!("Query sent with ID: {}", query_id);

	// Receive responses
	let mut received = 0;
	while received < 2 {
		match receiver.recv_timeout(Duration::from_secs(1)) {
			Ok(msg) => {
				match msg.response {
					Ok(ChannelResponse::Command {
						request_id,
						result,
					}) => {
						println!(
							"Command {} executed: {} frames returned",
							request_id,
							result.frames.len()
						);
						received += 1;
					}
					Ok(ChannelResponse::Query {
						request_id,
						result,
					}) => {
						println!(
							"Query {} executed: {} frames returned",
							request_id,
							result.frames.len()
						);
						// Print first frame if
						// available
						if let Some(frame) = result.frames.first() {
							println!("First frame:\n{}", frame);
						}
						received += 1;
					}
					Ok(ChannelResponse::Auth {
						..
					}) => {
						// Already handled above
					}
					Err(e) => {
						println!("Request {} failed: {}", msg.request_id, e);
						received += 1;
					}
				}
			}
			Err(_) => {
				println!("Timeout waiting for responses");
				break;
			}
		}
	}

	Ok(())
}

pub fn close(self) -> Result<(), Box<dyn Error>>

Close the client connection

Trait Implementations

impl Clone for WsClient

fn clone(&self) -> WsClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for WsClient

fn drop(&mut self)

Executes the destructor for this type.