Struct SqliteAdapter 

pub struct SqliteAdapter { /* private fields */ }

A SQLite database, materialized as an arbor.

Implementations

impl SqliteAdapter

pub fn open(path: &Path) -> Result<Self, SqliteError>

Open a database file (read-only): the catalog now, each table’s rows on first touch (the connection stays owned by the adapter).

pub fn open_with_refs( path: &Path, refs: &[(String, String)], ) -> Result<Self, SqliteError>

[open], with a declared-references document: each (field, container) pair supplies the edge the schema does not declare (see quarb_relational::parse_refs).

pub fn open_filtered( path: &Path, table: &str, where_sql: &str, ) -> Result<Self, SqliteError>

[open], with one table’s fetch filtered by a WHERE clause (partial pushdown; the engine re-applies the predicates).

pub fn open_filtered_with_refs( path: &Path, table: &str, where_sql: &str, refs: &[(String, String)], ) -> Result<Self, SqliteError>

[open_filtered], with a declared-references document.

pub fn from_bytes(bytes: &[u8]) -> Result<Self, SqliteError>

Open a database held entirely in memory — the bytes of a .db file that never touched a filesystem (the browser’s uploaded files). Deserializes read-only, then materializes eagerly, as SqliteAdapter::load does.

pub fn load(conn: &Connection) -> Result<Self, SqliteError>

Materialize every user table of an open connection, eagerly (in-memory databases, tests).

pub fn load_with_refs( conn: &Connection, refs: &[(String, String)], ) -> Result<Self, SqliteError>

[load], with a declared-references document.

pub fn locator(&self, node: NodeId) -> String

A human-readable locator: /table/key for rows.

Trait Implementations

impl AstAdapter for SqliteAdapter

fn root(&self) -> NodeId

The root node — the initial navigation context.

fn children(&self, node: NodeId) -> Vec<NodeId>

The tree children of node, in document order.

fn name(&self, node: NodeId) -> Option<String>

The name of node — the label of its incoming tree edge.

fn parent(&self, node: NodeId) -> Option<NodeId>

The parent of node, or None for the root.

fn property(&self, node: NodeId, name: &str) -> Option<Value>

A named property of node — ::prop. None if absent.

fn default_value(&self, node: NodeId) -> Option<Value>

The default projection of node — bare ::, adapter-specific (a filesystem adapter returns file content).

fn metadata(&self, node: NodeId, key: &str) -> Option<Value>

Adapter-defined metadata — ;;;key (a filesystem adapter’s size, modified, permissions, …). None if absent.

fn resolve( &self, node: NodeId, property: &str, hint: Option<&str>, ) -> Option<NodeId>

Resolve a cross-reference: ::property~>hint maps node’s property (a value that references another node) to its target, with an optional adapter-specific relation hint. A JSON adapter resolves a $ref JSON Pointer; None if unresolvable.

fn links(&self, node: NodeId) -> Vec<(String, NodeId)>

Outgoing crosslinks from node, as (label, target) pairs, for -> navigation (a filesystem adapter’s symlinks).

fn backlinks(&self, node: NodeId) -> Vec<(String, NodeId)>

Incoming crosslinks to node, as (label, source) pairs, for <- navigation. May be expensive (an adapter that does not precompute edges must search for referrers).

fn traits(&self, _node: NodeId) -> Vec<String>

The traits of node — its adapter-defined classifications, used by <trait> navigation filters (e.g. a filesystem adapter’s <dir>, <code>, <image>).

fn children_named(&self, node: NodeId, name: &str) -> Vec<NodeId>

The children of node whose edge name is exactly name — the engine’s fast path for name-matcher child hops. The default filters children; an adapter whose containers cannot be enumerated (permission-scoped or unbounded remote trees) overrides this with a direct, name-addressed lookup. Must be observationally identical to the default wherever enumeration works. The adapter owns the name test: it may deliberately alias — resolve a name to a node whose edge name differs (git revision syntax landing on a hash-named commit) — and the engine will not re-filter.

fn link_property( &self, _source: NodeId, _label: &str, _target: NodeId, _name: &str, ) -> Option<Value>

A property of the crosslink source --label--> target — the $-::prop read. Adapters whose edges carry data (a property graph’s relationship properties) override this; None if the edge is bare or unknown. Where parallel edges share source, label, and target, the adapter answers for one of them, consistently.

fn quantifier_bound(&self) -> usize

The quantifier bound N_max: the depth to which open-ended path quantifiers (+, *, {m,}) expand, and the ceiling of any explicit {m,n} (the effective upper bound is min(n, N_max)). An adapter whose natural structures run deep may raise it; the CLI overrides it per run (qua --quantifier-bound).

fn allow_shell(&self) -> bool

Whether the sh(...) pipeline stage may run external commands. False by default — query text stays inert data — and enabled per run by the CLI (qua --allow-shell) through the AllowShell wrapper.

fn invocation_instant(&self) -> Option<(i64, u32)>

The invocation instant now() denotes (spec: The Temporal Fragment, Determinism): one UTC timeline point bound by the runner BEFORE evaluation begins — evaluation itself never reads a clock. None by default (a library run is fully deterministic; now() reads as null); the CLI binds it at startup — pinnable with qua --now — through the WithNow wrapper.

fn unit_scale(&self, expr: &str) -> Option<(f64, String)>

The scale of a unit expression — (factor, canonical SI-base expansion) — for the unital reading’s criterion text (spec: The Quantital Fragment). The default answers from the engine’s frozen built-in table; a unit-aware adapter (kaiv) overrides it to include the mounted document’s own custom units, so [::range < '50kellicam'] resolves through the document’s .!units imports.