Struct Connection 

pub struct Connection { /* private fields */ }

A connection to the database for executing Cypher queries.

Created via Connection::new with a reference to a Database. Supports both ad-hoc queries and prepared statements.

Examples

use akar_main::database::{Database, SystemConfig};
use akar_main::connection::Connection;

let db = std::sync::Arc::new(Database::new("./my_db", SystemConfig::default())?);
let conn = Connection::new(&db);

// DDL
conn.query("CREATE NODE TABLE Person(name STRING, PRIMARY KEY(name))")?;

// DML
conn.query("CREATE (:Person {name: 'Alice'})")?;

// Query
let result = conn.query("MATCH (p:Person) RETURN p.name")?;
assert!(result.success);

Implementations

impl Connection

pub fn query(&self, query_str: &str) -> Result<QueryResult, String>

Execute a Cypher query and return the result.

pub fn prepare(&self, query_str: &str) -> Result<PreparedStatement, String>

Prepare a query for parameterized execution.

Parses and binds the query, extracting parameter names (like $name). The prepared statement can be executed multiple times with different parameter values via Connection::execute.

pub fn execute( &self, prepared: &PreparedStatement, params: Vec<(&str, Value)>, ) -> Result<QueryResult, String>

Execute a prepared statement with the given parameter values.

Parameters are provided as a vector of (name, value) pairs. The values are substituted for $name references in the query before planning and execution.

impl Connection

pub fn new(database: &Arc<Database>) -> Self

Create a new connection to the given database.

A connection owns a statement cache and transaction context. Multiple connections can coexist on the same Database — they share the buffer pool and catalog but hold independent transactions.

pub fn clear_cache(&self)

Clear the prepared statement and plan caches.

pub fn cache_size(&self) -> usize

Number of cached prepared statements.

pub fn plan_cache_size(&self) -> usize

Number of cached query plans.

Trait Implementations

impl Drop for Connection

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.