Struct Capabilities 

pub struct Capabilities {
    pub max_sql_len: usize,
    pub max_statements: usize,
    pub udf: bool,
    pub interactive_transactions: bool,
    pub int64_as_text: bool,
    pub max_compound_select: usize,
    pub compound_recursive_cte: bool,
    pub vectors: bool,
    pub vector_index_methods: bool,
    pub name: String,
    pub versioning: Versioning,
}

What a backend can do. The compiler adapts SQL generation to it.

Fields

max_sql_len: usize

Maximum length of one SQL statement in bytes (D1: 100 KB).

max_statements: usize

Maximum number of statements in one request.

udf: bool

The oxilite_* user-defined functions (regex, replace, hashes, Unicode case) exist.

interactive_transactions: bool

The backend supports interactive (read-then-write) transactions.

int64_as_text: bool

64-bit integers must be returned as TEXT (JavaScript numbers lose precision above 2^53).

max_compound_select: usize

Maximum number of terms in one compound SELECT (UNION ALL chain); D1 allows 5.

compound_recursive_cte: bool

A recursive CTE may have a compound recursive term (SQLite 3.34.0, 2020-12-01). A backend whose version cannot be established MUST leave this false: mutual recursion then takes a strategy that does not need it, instead of emitting SQL that would fail.

vectors: bool

Vector types and distance functions (vector32, vector_distance_cos…; Turso): vector indexes can be built and searched (see crate::vector).

vector_index_methods: bool

Index methods (CREATE INDEX … USING method; Turso): sparse vector indexes get an inverted-file index.

name: String

Name of the backend, for explain().

versioning: Versioning

The versioning level of the store (set by the store at open, not by the backend): from stamped on, writers record the current tick in quads.t.

Implementations

impl Capabilities

pub fn native() -> Self

A native SQLite linked in-process.

Examples found in repository

examples/../tests/golden/dump.rs (line 64)

pub fn dump(root: &Path) -> Vec<String> {
    let backends = [
        ("native", Capabilities::native()),
        ("d1", Capabilities::d1()),
    ];
    let mut paths = Vec::new();
    for sub in ["sparql10", "sparql11", "sparql12"] {
        files(&root.join(sub), &mut paths);
    }
    paths.sort();
    let mut out = Vec::new();
    let options = QueryOptions::default();
    let stats = Stats::default();
    for p in &paths {
        let Ok(text) = std::fs::read_to_string(p) else {
            continue;
        };
        // How `\u` escapes parse depends on spargebra's `standard-unicode-escaping` feature, which
        // workspace builds enable (for the W3C runner): leave those files out, so the rendering
        // depends on the compiler alone.
        if text.contains("\\u") || text.contains("\\U") {
            continue;
        }
        let rel = p.strip_prefix(root).unwrap().display().to_string();
        let parser = || {
            SparqlParser::new()
                .with_base_iri("http://example.com/base/")
                .unwrap()
        };
        let is_update = p.extension().and_then(|x| x.to_str()) == Some("ru");
        for (name, caps) in &backends {
            let render = || -> Option<String> {
                Some(if is_update {
                    match plan_update(&parser().parse_update(&text).ok()?, caps) {
                        Ok(plan) => explain_plan(&plan),
                        Err(e) => format!("ERR {e}"),
                    }
                } else {
                    match compile_query(&parser().parse_query(&text).ok()?, &stats, caps, &options)
                    {
                        Ok(c) => c.explain(),
                        Err(e) => format!("ERR {e}"),
                    }
                })
            };
            let Some(first) = render() else { continue };
            // Updates creating fresh blank nodes embed random ids: record that they vary.
            let h = if render().map(|r| hash(&r)) == Some(hash(&first)) {
                hash(&first)
            } else {
                "varies".to_owned()
            };
            out.push(format!("{rel}\t{name}\t{h}"));
        }
    }
    // The batch writer: inserts and deletes of a fixed set of quads.
    let ex = |s: String| oxrdf::NamedNode::new_unchecked(format!("http://example.com/{s}"));
    let quads: Vec<oxrdf::Quad> = (0..700)
        .map(|i| {
            oxrdf::Quad::new(
                ex(format!("s{i}")),
                ex(format!("p{}", i % 7)),
                oxrdf::Literal::new_simple_literal(format!("value {i}")),
                if i % 3 == 0 {
                    oxrdf::GraphName::DefaultGraph
                } else {
                    ex(format!("g{}", i % 5)).into()
                },
            )
        })
        .collect();
    let enc = EncodedQuads::new(quads.iter().map(oxrdf::Quad::as_ref));
    for (name, caps) in &backends {
        let ins: Vec<String> = enc
            .insert_statements(caps)
            .into_iter()
            .map(|s| s.sql)
            .collect();
        let del: Vec<String> = enc
            .delete_statements(caps)
            .into_iter()
            .map(|s| s.sql)
            .collect();
        out.push(format!("writer/insert\t{name}\t{}", hash(&ins.join("\n"))));
        out.push(format!("writer/delete\t{name}\t{}", hash(&del.join("\n"))));
    }
    out
}

pub fn d1() -> Self

Cloudflare D1 limits.

Examples found in repository

examples/../tests/golden/dump.rs (line 65)

pub fn dump(root: &Path) -> Vec<String> {
    let backends = [
        ("native", Capabilities::native()),
        ("d1", Capabilities::d1()),
    ];
    let mut paths = Vec::new();
    for sub in ["sparql10", "sparql11", "sparql12"] {
        files(&root.join(sub), &mut paths);
    }
    paths.sort();
    let mut out = Vec::new();
    let options = QueryOptions::default();
    let stats = Stats::default();
    for p in &paths {
        let Ok(text) = std::fs::read_to_string(p) else {
            continue;
        };
        // How `\u` escapes parse depends on spargebra's `standard-unicode-escaping` feature, which
        // workspace builds enable (for the W3C runner): leave those files out, so the rendering
        // depends on the compiler alone.
        if text.contains("\\u") || text.contains("\\U") {
            continue;
        }
        let rel = p.strip_prefix(root).unwrap().display().to_string();
        let parser = || {
            SparqlParser::new()
                .with_base_iri("http://example.com/base/")
                .unwrap()
        };
        let is_update = p.extension().and_then(|x| x.to_str()) == Some("ru");
        for (name, caps) in &backends {
            let render = || -> Option<String> {
                Some(if is_update {
                    match plan_update(&parser().parse_update(&text).ok()?, caps) {
                        Ok(plan) => explain_plan(&plan),
                        Err(e) => format!("ERR {e}"),
                    }
                } else {
                    match compile_query(&parser().parse_query(&text).ok()?, &stats, caps, &options)
                    {
                        Ok(c) => c.explain(),
                        Err(e) => format!("ERR {e}"),
                    }
                })
            };
            let Some(first) = render() else { continue };
            // Updates creating fresh blank nodes embed random ids: record that they vary.
            let h = if render().map(|r| hash(&r)) == Some(hash(&first)) {
                hash(&first)
            } else {
                "varies".to_owned()
            };
            out.push(format!("{rel}\t{name}\t{h}"));
        }
    }
    // The batch writer: inserts and deletes of a fixed set of quads.
    let ex = |s: String| oxrdf::NamedNode::new_unchecked(format!("http://example.com/{s}"));
    let quads: Vec<oxrdf::Quad> = (0..700)
        .map(|i| {
            oxrdf::Quad::new(
                ex(format!("s{i}")),
                ex(format!("p{}", i % 7)),
                oxrdf::Literal::new_simple_literal(format!("value {i}")),
                if i % 3 == 0 {
                    oxrdf::GraphName::DefaultGraph
                } else {
                    ex(format!("g{}", i % 5)).into()
                },
            )
        })
        .collect();
    let enc = EncodedQuads::new(quads.iter().map(oxrdf::Quad::as_ref));
    for (name, caps) in &backends {
        let ins: Vec<String> = enc
            .insert_statements(caps)
            .into_iter()
            .map(|s| s.sql)
            .collect();
        let del: Vec<String> = enc
            .delete_statements(caps)
            .into_iter()
            .map(|s| s.sql)
            .collect();
        out.push(format!("writer/insert\t{name}\t{}", hash(&ins.join("\n"))));
        out.push(format!("writer/delete\t{name}\t{}", hash(&del.join("\n"))));
    }
    out
}

Trait Implementations

impl Clone for Capabilities

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Capabilities

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

Formats the value using the given formatter.

impl Default for Capabilities

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Capabilities

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Capabilities