Agdb Query

// Select all values by id
QueryBuilder::select().ids(1).query();
// Select specific keys
QueryBuilder::select().values(["k".into()]).ids([1, 2]).query();
// Select keys only (no values)
QueryBuilder::select().keys().ids([1, 2]).query();
// Select key count
QueryBuilder::select().key_count().ids([1, 2]).query();
// Select edge count (from/to/both)
QueryBuilder::select().edge_count_from().ids(1).query();
QueryBuilder::select().edge_count_to().ids(1).query();
QueryBuilder::select().edge_count().ids(1).query();
// Select aliases
QueryBuilder::select().aliases().ids(1).query();
QueryBuilder::select().aliases().query(); // all aliases
// Select indexes
QueryBuilder::select().indexes().query();
// Select node count
QueryBuilder::select().node_count().query();
// Search - BFS (default) from alias
QueryBuilder::search().from("alias").query();
// Search - path search (A*)
QueryBuilder::search().from(1).to(2).query();
// Search - index lookup (fastest for single-key equality)
QueryBuilder::search().index("username").value("alice").query();
// Search - full element scan
QueryBuilder::search().elements().query();
// Nested: select values via search result
QueryBuilder::select().search().from("alias").where_().node().query();
// Nested: typed select (single result, limit=1)
QueryBuilder::select().element::<User>().search().from("alias").where_().key("name").value("Alice").query();
// Nested: typed select (all matches)
QueryBuilder::select().elements::<User>().search().from("alias").where_().node().query();

// Insert nodes
QueryBuilder::insert().nodes().count(1).query();
QueryBuilder::insert().nodes().aliases(["root"]).query();
QueryBuilder::insert().nodes().values(&typed_vec).query();
// Upsert (insert or update): pass existing ids
QueryBuilder::insert().nodes().ids(existing_ids).values(&typed_vec).query();
// Insert edges
QueryBuilder::insert().edges().from(1).to(2).query();
QueryBuilder::insert().edges().from("alias_a").to([3, 4, 5]).query();
QueryBuilder::insert().edges().from(1).to(2).values([[("weight", 10).into()]]).query();
// Insert/update aliases
QueryBuilder::insert().aliases(["name"]).ids(1).query();
// Insert/update values
QueryBuilder::insert().values([vec![("k", 1).into()]]).ids(1).query();
QueryBuilder::insert().values_uniform([("k", 1).into()]).ids(1).query();
// Insert single typed element (DbElement)
QueryBuilder::insert().element(typed_element).query();
// Insert multiple typed elements (DbElement)
QueryBuilder::insert().elements(&typed_elements).query();
// Create index
QueryBuilder::insert().index("key").query();
// Remove elements
QueryBuilder::remove().ids([1, 2]).query();
// Remove aliases (not the elements)
QueryBuilder::remove().aliases("name").query();
// Remove specific properties
QueryBuilder::remove().values("key").ids(1).query();
// Remove index
QueryBuilder::remove().index("key").query();

// Add to numeric value (saturating), append to string/vec
QueryBuilder::insert().amend([vec![("score", 10).into()]]).ids(1).query();
// Same value applied uniformly to multiple elements
QueryBuilder::insert().amend_uniform([("score", 10).into()]).ids([1, 2]).query();
// Subtract from numeric value, remove first occurrence from string/vec
QueryBuilder::remove().amend([vec![("tags", "old_tag").into()]]).ids(1).query();
// Bitwise operations on integer/byte values
QueryBuilder::insert().amend_or([vec![("flags", 0x04_u64).into()]]).ids(1).query();
QueryBuilder::insert().amend_and([vec![("mask", 0xFF_u64).into()]]).ids(1).query();
QueryBuilder::insert().amend_xor([vec![("toggle", 0x01_u64).into()]]).ids(1).query();
// Uniform variants: amend_or_uniform, amend_and_uniform, amend_xor_uniform

.where_().node()
.where_().edge()
.where_().key("k").value(1)
.where_().keys(["k1".into(), "k2".into()])
.where_().distance_less_than_or_equal(2)
.where_().ids([1, 2, 3])

.where_().node().or().edge()
.where_().node().and().key("k").value("v")
.where_().node().or().where_().edge().and().key("k").value(1).end_where()

.where_().distance_less_than(3)              // same as .distance(CountComparison::LessThan(3))
.where_().distance_less_than_or_equal(3)
.where_().distance_greater_than(1)
.where_().distance_greater_than_or_equal(1)
.where_().distance_not_equal(0)
.where_().neighbor()                         // shorthand for distance == 2

.where_().key("age").greater_than(18)        // same as .value(Comparison::GreaterThan(18.into()))
.where_().key("age").greater_than_or_equal(18)
.where_().key("age").less_than(65)
.where_().key("age").less_than_or_equal(65)
.where_().key("name").not_equal("admin")
.where_().key("name").contains("alice")      // substring/element match
.where_().key("name").starts_with("user_")
.where_().key("name").ends_with("_admin")
.where_().key("role").any(["admin", "mod"])   // matches if value is any of the list
.where_().key("name").regex("^user_\\d+$")   // regex match on string values

.where_().edge_count_from_greater_than(0)    // has outgoing edges
.where_().edge_count_to_less_than(5)         // fewer than 5 incoming edges
// also: edge_count_*, edge_count_from_*, edge_count_to_* with _less_than, _greater_than, _not_equal, etc.

QueryBuilder::search().from("root").order_by([DbKeyOrder::Asc("name".into())]).query();