API Reference

use kolibrie::SparqlDatabase;

let mut db = SparqlDatabase::new();

from py_kolibrie import PySparqlDatabase

db = PySparqlDatabase()

db.parse_rdf("<rdf:RDF ...>...</rdf:RDF>");
db.parse_rdf_from_file("dataset.rdf");        // parallelized
db.parse_turtle("@prefix ex: <http://ex.org/> . ex:Alice ex:knows ex:Bob .");
db.parse_n3("{ ?X ex:knows ?Y . } => { ?Y ex:knownBy ?X . } .");
db.parse_ntriples_and_add("<http://ex.org/s> <http://ex.org/p> <http://ex.org/o> .");

db.add_triple_parts(
    "http://example.org/Alice",
    "http://example.org/knows",
    "http://example.org/Bob",
);

let removed = db.delete_triple_parts(
    "http://example.org/Alice",
    "http://example.org/knows",
    "http://example.org/Bob",
);

db.build_all_indexes();

use kolibrie::execute_query::execute_query;

let results = execute_query(
    "PREFIX ex: <http://example.org/> SELECT ?s WHERE { ?s ex:knows ex:Bob }",
    &mut db,
);
for row in results {
    println!("{}", row[0]);
}

use kolibrie::execute_query::execute_query_rayon_parallel2_volcano;

let results = execute_query_rayon_parallel2_volcano(sparql_str, &mut db);

let results = db.query()
    .with_predicate("http://example.org/knows")
    .distinct()
    .get_decoded_triples();

db.get_or_build_stats();

db.invalidate_stats_cache();

db.register_udf("toUpperCase", |args: Vec<String>| -> String {
    args.into_iter().map(|s| s.to_uppercase()).collect::<Vec<_>>().join("")
});

SELECT ?upper WHERE {
  ?p ex:name ?name .
  BIND(toUpperCase(?name) AS ?upper)
}

let rdf_xml = db.generate_rdf_xml();
std::fs::write("output.rdf", rdf_xml).unwrap();

cargo run --bin kolibrie-http-server
# Server available at http://localhost:8080

docker compose up --build

{
  "sparql": "SELECT ?s ?p ?o WHERE { ?s ?p ?o }",
  "rdf": "<optional RDF/XML data to load>",
  "format": "rdfxml",
  "rule": "optional SPARQL RULE definition string",
  "n3logic": "optional N3 logic rules",
  "queries": ["optional array of SPARQL strings for batch execution"]
}

{
  "results": [
    {
      "query_index": 0,
      "query": "SELECT ...",
      "data": [["Alice", "knows", "Bob"]],
      "execution_time_ms": 1.23
    }
  ]
}

curl -X POST http://localhost:8080/query \
  -H "Content-Type: application/json" \
  -d '{
    "rdf": "@prefix ex: <http://example.org/> . ex:Alice ex:knows ex:Bob .",
    "format": "turtle",
    "sparql": "PREFIX ex: <http://example.org/> SELECT ?s ?o WHERE { ?s ex:knows ?o }"
  }'

{
  "query": "REGISTER RSTREAM <http://output/stream> AS SELECT * FROM NAMED WINDOW :w ON :s [RANGE PT10M STEP PT1M] WHERE { WINDOW :w { ?s ?p ?o } }",
  "static_rdf": "<optional background RDF/XML joined with every window>",
  "n3logic": "optional N3 rules",
  "sparql_rules": ["optional SPARQL RULE strings"]
}

{
  "session_id": "session_1",
  "streams": [":s"]
}

{
  "session_id": "session_1",
  "stream": ":s",
  "timestamp": 1000,
  "ntriples": "<http://ex.org/sensor1> <http://ex.org/temperature> \"72.5\" ."
}

curl -X POST http://localhost:8080/rsp/push \
  -H "Content-Type: application/json" \
  -d '{
    "session_id": "session_1",
    "stream": ":s",
    "timestamp": 1000,
    "ntriples": "<http://ex.org/r1> <http://ex.org/value> \"42\" ."
  }'

curl -N http://localhost:8080/rsp/stream/session_1

{
  "query": "SELECT * FROM NAMED WINDOW :w ON :s [RANGE PT10M STEP PT1M] WHERE { WINDOW :w { ?s ?p ?o } }",
  "events": [
    { "stream": ":s", "timestamp": 100, "ntriples": "<http://ex.org/r1> <http://ex.org/p> <http://ex.org/v> ." }
  ],
  "static_rdf": ""
}

from py_kolibrie import PySparqlDatabase, PyStreamOperator

db = PySparqlDatabase()

stream = (db.query()
            .window(size=10, step=2)
            .with_predicate("http://example.org/knows")
            .with_stream_operator(PyStreamOperator.RSTREAM)
            .as_stream())

stream.add_stream_triple("http://example.org/Alice",
                         "http://example.org/knows",
                         "http://example.org/Bob",
                         timestamp=1)
stream.add_stream_triple("http://example.org/Bob",
                         "http://example.org/knows",
                         "http://example.org/Carol",
                         timestamp=3)

batches = stream.get_stream_results()
for batch in batches:
    for subject, predicate, obj in batch:
        print(f"{subject} -> {obj}")

stream.stop_stream()

use datalog::reasoning::Reasoner;

use datalog::reasoning::Reasoner;
use shared::terms::Term;
use shared::rule::Rule;

let mut kg = Reasoner::new();
kg.add_abox_triple("Alice", "hasParent", "Bob");
kg.add_abox_triple("Bob",   "hasParent", "Charlie");

let parent_id      = kg.dictionary.write().unwrap().encode("hasParent");
let grandparent_id = kg.dictionary.write().unwrap().encode("hasGrandparent");

kg.add_rule(Rule {
    premise: vec![
        (Term::Variable("X".into()), Term::Constant(parent_id), Term::Variable("Y".into())),
        (Term::Variable("Y".into()), Term::Constant(parent_id), Term::Variable("Z".into())),
    ],
    negative_premise: vec![],
    conclusion: vec![(
        Term::Variable("X".into()),
        Term::Constant(grandparent_id),
        Term::Variable("Z".into()),
    )],
    filters: vec![],
});

let inferred = kg.infer_new_facts_semi_naive();
// ["Alice hasGrandparent Charlie"]

import py_kolibrie

import py_kolibrie

graph = py_kolibrie.PyKnowledgeGraph()
graph.add_abox_triple("Alice", "hasParent", "Bob")
graph.add_abox_triple("Bob",   "hasParent", "Charlie")

has_parent      = graph.encode_term("hasParent")
has_grandparent = graph.encode_term("hasGrandparent")

rule = py_kolibrie.PyRule(
    premise=[
        py_kolibrie.PyTriplePattern(
            py_kolibrie.PyTerm.Variable("X"),
            py_kolibrie.PyTerm.Constant(has_parent),
            py_kolibrie.PyTerm.Variable("Y")),
        py_kolibrie.PyTriplePattern(
            py_kolibrie.PyTerm.Variable("Y"),
            py_kolibrie.PyTerm.Constant(has_parent),
            py_kolibrie.PyTerm.Variable("Z")),
    ],
    filters=[],
    conclusion=[py_kolibrie.PyTriplePattern(
        py_kolibrie.PyTerm.Variable("X"),
        py_kolibrie.PyTerm.Constant(has_grandparent),
        py_kolibrie.PyTerm.Variable("Z"),
    )],
)
graph.add_rule(rule)

inferred = graph.infer_new_facts()
for subject, predicate, obj in inferred:
    print(f"{subject} {predicate} {obj}")

use kolibrie::SparqlDatabase;
use kolibrie::query_builder::QueryBuilder;

let db = SparqlDatabase::new();
let query = QueryBuilder::new(&db);

from py_kolibrie import PySparqlDatabase

db = PySparqlDatabase()
query = db.query()

let results = QueryBuilder::new(&db)
    .with_subject("http://example.org/Alice")
    .get_decoded_triples();

results = (db.query()
    .with_subject("http://example.org/Alice")
    .get_decoded_triples())

let results = QueryBuilder::new(&db)
    .with_subject_like("example.org")
    .get_decoded_triples();

let results = QueryBuilder::new(&db)
    .with_subject_starting("http://example.org/")
    .get_decoded_triples();

let results = QueryBuilder::new(&db)
    .with_subject_ending("Alice")
    .get_decoded_triples();

let results = QueryBuilder::new(&db)
    .with_predicate("http://example.org/knows")
    .get_decoded_triples();

results = (db.query()
    .with_predicate("http://example.org/knows")
    .get_decoded_triples())

let results = QueryBuilder::new(&db)
    .with_object("http://example.org/Bob")
    .get_decoded_triples();

let results = QueryBuilder::new(&db)
    .filter(|triple| {
        db.dictionary.decode(triple.subject)
            .map(|s| s.contains("Alice"))
            .unwrap_or(false)
    })
    .get_decoded_triples();

let other_db = SparqlDatabase::new();
// ... populate other_db ...

let results = QueryBuilder::new(&db)
    .join(&other_db)
    .join_on_subject()
    .get_decoded_triples();

let results = QueryBuilder::new(&db)
    .join(&other_db)
    .join_with(|left, right| {
        left.subject == right.object
    })
    .get_decoded_triples();

let results = QueryBuilder::new(&db)
    .order_by(|triple| {
        db.dictionary.decode(triple.subject).unwrap_or("").to_string()
    })
    .get_decoded_triples();

let results = QueryBuilder::new(&db)
    .order_by(|triple| {
        db.dictionary.decode(triple.subject).unwrap_or("").to_string()
    })
    .desc()
    .get_decoded_triples();

let results = QueryBuilder::new(&db)
    .with_predicate_like("knows")
    .distinct()
    .get_decoded_triples();

results = (db.query()
    .with_predicate_like("knows")
    .distinct()
    .get_decoded_triples())

let results = QueryBuilder::new(&db)
    .limit(10)
    .get_decoded_triples();

results = (db.query()
    .limit(10)
    .get_decoded_triples())

let results = QueryBuilder::new(&db)
    .offset(20)
    .limit(10)  // Get results 21-30
    .get_decoded_triples();

let subjects = QueryBuilder::new(&db)
    .with_predicate("http://example.org/knows")
    .distinct()
    .get_subjects();

let count = QueryBuilder::new(&db)
    .with_predicate("http://example.org/knows")
    .count();
println!("Found {} relationships", count);

count = (db.query()
    .with_predicate("http://example.org/knows")
    .count())
print(f"Found {count} relationships")

let groups = QueryBuilder::new(&db)
    .group_by(|triple| triple.predicate);

for (predicate_id, triples) in groups {
    println!("Predicate {}: {} triples", predicate_id, triples.len());
}

from py_kolibrie import PySparqlDatabase

def main():
    db = PySparqlDatabase()
    db.add_triple("http://example.org/Alice", "http://example.org/knows", "http://example.org/Bob")
    db.add_triple("http://example.org/Bob", "http://example.org/knows", "http://example.org/Carol")
    db.add_triple("http://example.org/Alice", "http://example.org/likes", "http://example.org/IceCream")

    query = (db.query()
        .with_subject("http://example.org/Alice")
        .distinct()
        .limit(20))

    triples = query.get_decoded_triples()
    print("Decoded triples:")
    for s, p, o in triples:
        print(f"  {s} -- {p} --> {o}")

    subjects = query.get_subjects()
    print("\nDistinct subjects:")
    for s in subjects:
        print(" ", s)

    count = query.count()
    print(f"\nTotal matching triples: {count}")

if __name__ == "__main__":
    main()

results = (db.query()
    .with_subject_like("example.org")
    .with_predicate("http://example.org/knows")
    .distinct()
    .limit(50)
    .get_decoded_triples())

let results = QueryBuilder::new(&db)
    .with_subject_like("example.org")
    .with_predicate("http://example.org/knows")
    .distinct()
    .limit(50)
    .get_decoded_triples();