add data packages and remove empty submodule

packages/data/tst/examples/prefix_ops.rs

@@ -0,0 +1,184 @@
+use std::time::Instant;
+use tst::TST;
+
+fn main() -> Result<(), tst::Error> {
+    // Create a temporary directory for the database
+    let db_path = std::env::temp_dir().join("tst_prefix_example");
+    std::fs::create_dir_all(&db_path)?;
+
+    println!("Creating ternary search tree at: {}", db_path.display());
+
+    // Create a new TST
+    let mut tree = TST::new(db_path.to_str().unwrap(), true)?;
+
+    // Insert a variety of keys with different prefixes
+    println!("Inserting data with various prefixes...");
+
+    // Names
+    let names = [
+        "Alice",
+        "Alexander",
+        "Amanda",
+        "Andrew",
+        "Amy",
+        "Bob",
+        "Barbara",
+        "Benjamin",
+        "Brenda",
+        "Brian",
+        "Charlie",
+        "Catherine",
+        "Christopher",
+        "Cynthia",
+        "Carl",
+        "David",
+        "Diana",
+        "Daniel",
+        "Deborah",
+        "Donald",
+        "Edward",
+        "Elizabeth",
+        "Eric",
+        "Emily",
+        "Ethan",
+    ];
+
+    for (i, name) in names.iter().enumerate() {
+        let value = format!("person-{}", i).into_bytes();
+        tree.set(name, value)?;
+    }
+
+    // Cities
+    let cities = [
+        "New York",
+        "Los Angeles",
+        "Chicago",
+        "Houston",
+        "Phoenix",
+        "Philadelphia",
+        "San Antonio",
+        "San Diego",
+        "Dallas",
+        "San Jose",
+        "Austin",
+        "Jacksonville",
+        "Fort Worth",
+        "Columbus",
+        "San Francisco",
+        "Charlotte",
+        "Indianapolis",
+        "Seattle",
+        "Denver",
+        "Washington",
+    ];
+
+    for (i, city) in cities.iter().enumerate() {
+        let value = format!("city-{}", i).into_bytes();
+        tree.set(city, value)?;
+    }
+
+    // Countries
+    let countries = [
+        "United States",
+        "Canada",
+        "Mexico",
+        "Brazil",
+        "Argentina",
+        "United Kingdom",
+        "France",
+        "Germany",
+        "Italy",
+        "Spain",
+        "China",
+        "Japan",
+        "India",
+        "Australia",
+        "Russia",
+    ];
+
+    for (i, country) in countries.iter().enumerate() {
+        let value = format!("country-{}", i).into_bytes();
+        tree.set(country, value)?;
+    }
+
+    println!(
+        "Total items inserted: {}",
+        names.len() + cities.len() + countries.len()
+    );
+
+    // Test prefix operations
+    test_prefix(&mut tree, "A")?;
+    test_prefix(&mut tree, "B")?;
+    test_prefix(&mut tree, "C")?;
+    test_prefix(&mut tree, "San")?;
+    test_prefix(&mut tree, "United")?;
+
+    // Test non-existent prefix
+    test_prefix(&mut tree, "Z")?;
+
+    // Test empty prefix (should return all keys)
+    println!("\nTesting empty prefix (should return all keys):");
+    let start = Instant::now();
+    let all_keys = tree.list("")?;
+    let duration = start.elapsed();
+
+    println!(
+        "Found {} keys with empty prefix in {:?}",
+        all_keys.len(),
+        duration
+    );
+    println!("First 5 keys (alphabetically):");
+    for key in all_keys.iter().take(5) {
+        println!("  {}", key);
+    }
+
+    // Clean up (optional)
+    if std::env::var("KEEP_DB").is_err() {
+        std::fs::remove_dir_all(&db_path)?;
+        println!("\nCleaned up database directory");
+    } else {
+        println!("\nDatabase kept at: {}", db_path.display());
+    }
+
+    Ok(())
+}
+
+fn test_prefix(tree: &mut TST, prefix: &str) -> Result<(), tst::Error> {
+    println!("\nTesting prefix '{}':", prefix);
+
+    // Test list operation
+    let start = Instant::now();
+    let keys = tree.list(prefix)?;
+    let list_duration = start.elapsed();
+
+    println!(
+        "Found {} keys with prefix '{}' in {:?}",
+        keys.len(),
+        prefix,
+        list_duration
+    );
+
+    if !keys.is_empty() {
+        println!("Keys:");
+        for key in &keys {
+            println!("  {}", key);
+        }
+
+        // Test getall operation
+        let start = Instant::now();
+        let values = tree.getall(prefix)?;
+        let getall_duration = start.elapsed();
+
+        println!("Retrieved {} values in {:?}", values.len(), getall_duration);
+        println!(
+            "First value: {}",
+            if !values.is_empty() {
+                String::from_utf8_lossy(&values[0])
+            } else {
+                "None".into()
+            }
+        );
+    }
+
+    Ok(())
+}