Struct FlatBuffersSerializer 

pub struct FlatBuffersSerializer;

Serializes a batch of QueryEvents to FlexBuffers format

FlexBuffers is a schema-less binary format from the FlatBuffers project that provides efficient serialization without requiring code generation.

It’s ideal for our use case: high performance, compact, and works with serde.

Implementations

impl FlatBuffersSerializer

pub fn serialize_batch( events: &[QueryEvent], proxy_id: &str, batch_seq: u64, ) -> Vec<u8>

Serialize a batch of events to FlexBuffers binary format

Returns the serialized bytes ready to send over the wire

Examples found in repository

examples/serialize.rs (line 38)

fn main() {
    println!("Scry Protocol - Serialization Example\n");

    // Create some sample events
    let events = vec![
        QueryEventBuilder::new("SELECT * FROM users WHERE id = 1")
            .connection_id("conn-001")
            .database("production")
            .duration(Duration::from_millis(5))
            .rows(1)
            .build(),
        QueryEventBuilder::new("INSERT INTO orders (user_id, total) VALUES (1, 99.99)")
            .connection_id("conn-001")
            .database("production")
            .duration(Duration::from_millis(3))
            .rows(1)
            .build(),
        QueryEventBuilder::new("INVALID SQL QUERY")
            .connection_id("conn-002")
            .database("production")
            .duration(Duration::from_millis(1))
            .success(false)
            .error("syntax error at or near \"INVALID\"")
            .build(),
    ];

    println!("Created {} events:", events.len());
    for (i, event) in events.iter().enumerate() {
        println!("  {}. {} ({})", i + 1, event.query, if event.success { "success" } else { "failed" });
    }

    // Serialize the batch
    let proxy_id = "proxy-demo";
    let batch_seq = 0;
    let bytes = FlatBuffersSerializer::serialize_batch(&events, proxy_id, batch_seq);

    println!("\nSerialized batch:");
    println!("  Proxy ID: {}", proxy_id);
    println!("  Batch seq: {}", batch_seq);
    println!("  Event count: {}", events.len());
    println!("  Binary size: {} bytes", bytes.len());
    println!("  Average bytes/event: {} bytes", bytes.len() / events.len());

    // Show first 32 bytes in hex
    println!("\nFirst 32 bytes (hex):");
    let preview = &bytes[..bytes.len().min(32)];
    for (i, byte) in preview.iter().enumerate() {
        if i > 0 && i % 16 == 0 {
            println!();
        }
        print!("{:02x} ", byte);
    }
    println!();

    println!("\nSerialization complete! These bytes can now be sent over the network.");
}

examples/deserialize.rs (line 31)

fn main() {
    println!("Scry Protocol - Deserialization Example\n");

    // First, create and serialize some events
    // (In a real scenario, these bytes would come from the network)
    println!("Creating sample batch...");
    let events = vec![
        QueryEventBuilder::new("SELECT * FROM users WHERE id = 1")
            .connection_id("conn-001")
            .database("production")
            .duration(Duration::from_millis(5))
            .rows(1)
            .build(),
        QueryEventBuilder::new("UPDATE users SET last_login = NOW() WHERE id = 1")
            .connection_id("conn-001")
            .database("production")
            .duration(Duration::from_millis(8))
            .rows(1)
            .build(),
        QueryEventBuilder::new("SELECT COUNT(*) FROM orders WHERE user_id = 1")
            .connection_id("conn-001")
            .database("production")
            .duration(Duration::from_millis(12))
            .rows(1)
            .build(),
    ];

    let bytes = FlatBuffersSerializer::serialize_batch(&events, "proxy-demo", 42);
    println!("Serialized {} events into {} bytes\n", events.len(), bytes.len());

    // Now deserialize the batch
    println!("Deserializing batch...");
    match FlexBuffersDeserializer::deserialize_batch(&bytes) {
        Ok(batch) => {
            println!("Deserialization successful!\n");

            println!("Batch metadata:");
            println!("  Proxy ID: {}", batch.proxy_id);
            println!("  Batch sequence: {}", batch.batch_seq);
            println!("  Event count: {}\n", batch.events.len());

            println!("Events:");
            for (i, event) in batch.events.iter().enumerate() {
                println!("  Event {}:", i + 1);
                println!("    ID: {}", event.event_id);
                println!("    Query: {}", event.query);
                println!("    Database: {}", event.database);
                println!("    Connection: {}", event.connection_id);
                println!("    Duration: {:?}", event.duration);
                println!("    Rows: {:?}", event.rows);
                println!("    Success: {}", event.success);
                if let Some(err) = &event.error {
                    println!("    Error: {}", err);
                }
                println!();
            }

            println!("All events deserialized successfully!");
        }
        Err(e) => {
            eprintln!("Deserialization failed: {}", e);
            std::process::exit(1);
        }
    }
}