Struct FrameColumn 

pub struct FrameColumn {
    pub namespace: Option<String>,
    pub source: Option<String>,
    pub name: String,
    pub data: FrameColumnData,
}

Fields

namespace: Option<String>

source: Option<String>

name: String

data: FrameColumnData

Implementations

impl FrameColumn

pub fn qualified_name(&self) -> String

Methods from Deref<Target = FrameColumnData>

pub fn get_type(&self) -> Type

pub fn is_defined(&self, idx: usize) -> bool

pub fn is_bool(&self) -> bool

pub fn is_float(&self) -> bool

pub fn is_utf8(&self) -> bool

pub fn is_number(&self) -> bool

pub fn is_text(&self) -> bool

pub fn is_temporal(&self) -> bool

pub fn is_uuid(&self) -> bool

pub fn iter<'a>(&'a self) -> Box<dyn Iterator<Item = Value> + 'a>

pub fn len(&self) -> usize

Examples found in repository

examples/test_remote_sort.rs (line 38)

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 as_string(&self, index: usize) -> String

Examples found in repository

examples/test_remote_sort.rs (line 39)

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 get_value(&self, index: usize) -> Value

Trait Implementations

impl Clone for FrameColumn

fn clone(&self) -> FrameColumn

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FrameColumn

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for FrameColumn

type Target = FrameColumnData

The resulting type after dereferencing.

fn deref(&self) -> &<FrameColumn as Deref>::Target

Dereferences the value.

impl<'de> Deserialize<'de> for FrameColumn

fn deserialize<__D>( __deserializer: __D, ) -> Result<FrameColumn, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for FrameColumn

fn eq(&self, other: &FrameColumn) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for FrameColumn

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for FrameColumn