aarondb - v4.1.0

aarondb/q

Types

QueryBuilder 

pub type QueryBuilder {
  QueryBuilder(
    find: List(String),
    clauses: List(ast.BodyClause),
    order_by: option.Option(ast.OrderBy),
    limit: option.Option(Int),
    offset: option.Option(Int),
  )
}

Constructors

Values

avg 

pub fn avg(
  builder: QueryBuilder,
  into: String,
  target: String,
  filter: List(ast.BodyClause),
) -> QueryBuilder

Avg aggregate

betweenness_centrality 

pub fn betweenness_centrality(
  builder: QueryBuilder,
  edge: String,
  entity_var: String,
  score_var: String,
) -> QueryBuilder

Calculate betweenness centrality (Brandes’ algorithm) for each node.

cognitive 

pub fn cognitive(
  builder: QueryBuilder,
  concept: ast.Part,
  context: ast.Part,
  threshold: Float,
  engram_var: String,
) -> QueryBuilder

Semantic cognitive search over stored concept, context, and relevance facts.

connected_components 

pub fn connected_components(
  builder: QueryBuilder,
  edge: String,
  entity_var: String,
  component_var: String,
) -> QueryBuilder

Label each node with a connected component ID.

count 

pub fn count(
  builder: QueryBuilder,
  into: String,
  target: String,
  filter: List(ast.BodyClause),
) -> QueryBuilder

Count aggregate

cycle_detect 

pub fn cycle_detect(
  builder: QueryBuilder,
  edge: String,
  cycle_var: String,
) -> QueryBuilder

Detect cycles in directed graph. Each result binds a List of entity refs forming a cycle.

filter 

pub fn filter(
  builder: QueryBuilder,
  expr: ast.Expression,
) -> QueryBuilder

Generic filter expression.

from_clauses 

pub fn from_clauses(
  clauses: List(ast.BodyClause),
) -> QueryBuilder

i 

pub fn i(val: Int) -> ast.Part

Helper for int value

limit 

pub fn limit(builder: QueryBuilder, n: Int) -> QueryBuilder

Limit results

max 

pub fn max(
  builder: QueryBuilder,
  into: String,
  target: String,
  filter: List(ast.BodyClause),
) -> QueryBuilder

Max aggregate

median 

pub fn median(
  builder: QueryBuilder,
  into: String,
  target: String,
  filter: List(ast.BodyClause),
) -> QueryBuilder

Median aggregate

min 

pub fn min(
  builder: QueryBuilder,
  into: String,
  target: String,
  filter: List(ast.BodyClause),
) -> QueryBuilder

Min aggregate

negate 

pub fn negate(
  builder: QueryBuilder,
  entity: ast.Part,
  attr: String,
  value: ast.Part,
) -> QueryBuilder

Add a negative where clause (Entity, Attribute, Value).

neighbors 

pub fn neighbors(
  builder: QueryBuilder,
  from: ast.Part,
  edge: String,
  depth: Int,
  node_var: String,
) -> QueryBuilder

Find all nodes within K hops of a starting node.

new 

pub fn new() -> QueryBuilder

offset 

pub fn offset(builder: QueryBuilder, n: Int) -> QueryBuilder

Offset results

order_by 

pub fn order_by(
  builder: QueryBuilder,
  variable: String,
  direction: ast.OrderDirection,
) -> QueryBuilder

Order results

pagerank 

pub fn pagerank(
  builder: QueryBuilder,
  entity_var: String,
  edge: String,
  rank_var: String,
  damping damping: Float,
  iterations iterations: Int,
) -> QueryBuilder

Calculate PageRank for nodes connected by an edge.

pull 

pub fn pull(
  builder: QueryBuilder,
  variable: String,
  entity: ast.Part,
  pattern: List(ast.PullItem),
) -> QueryBuilder

Pull attributes for an entity into a variable.

reachable 

pub fn reachable(
  builder: QueryBuilder,
  from: ast.Part,
  edge: String,
  node_var: String,
) -> QueryBuilder

Find all nodes reachable from a starting node.

s 

pub fn s(val: String) -> ast.Part

Helper for string value

select 

pub fn select(vars: List(String)) -> QueryBuilder

shortest_path 

pub fn shortest_path(
  builder: QueryBuilder,
  from: ast.Part,
  to: ast.Part,
  edge: String,
  path_var: String,
  cost_var cost_var: option.Option(String),
  max_depth max_depth: option.Option(Int),
) -> QueryBuilder

Find the shortest path between two entities via an edge attribute.

similar 

pub fn similar(
  builder: QueryBuilder,
  variable: String,
  vector: List(Float),
  threshold: Float,
) -> QueryBuilder

Vector similarity search: binds variable to entities whose stored vector is within threshold of vector, resolved by the engine’s vector/HNSW index. (Previously this emitted a value-equality Positive clause — a placeholder — now it emits the real ast.Similarity clause.)

since 

pub fn since(
  builder: QueryBuilder,
  variable: String,
  val: ast.Part,
) -> QueryBuilder

Filter results since a specific value (exclusive)

sum 

pub fn sum(
  builder: QueryBuilder,
  into: String,
  target: String,
  filter: List(ast.BodyClause),
) -> QueryBuilder

Sum aggregate

temporal_at 

pub fn temporal_at(
  builder: QueryBuilder,
  variable: String,
  entity: ast.Part,
  tx: Int,
) -> QueryBuilder

Bind variable to the transaction-time basis used by nested clauses.

This is an exact At query: nested clauses observe only datoms whose transaction id is at most tx. For a complete query-level snapshot API, prefer aarondb.as_of_tx.

to_clauses 

pub fn to_clauses(builder: QueryBuilder) -> List(ast.BodyClause)

Convert builder to a list of clauses for backwards compatibility. NOTE: This will lose find/limit/offset/order info.

to_query 

pub fn to_query(builder: QueryBuilder) -> ast.Query

Convert builder to a full Query AST.

topological_sort 

pub fn topological_sort(
  builder: QueryBuilder,
  edge: String,
  entity_var: String,
  order_var: String,
) -> QueryBuilder

Topological ordering of a DAG. Returns empty if cycles exist.

v 

pub fn v(name: String) -> ast.Part

Helper for variable

valid_temporal_at 

pub fn valid_temporal_at(
  builder: QueryBuilder,
  variable: String,
  entity: ast.Part,
  valid_time: Int,
) -> QueryBuilder

Bind variable to the valid-time basis used by nested clauses.

This is an exact At query: nested clauses observe only datoms whose valid time is at most valid_time. For a complete query-level snapshot API, prefer aarondb.as_of_valid.

vec 

pub fn vec(val: List(Float)) -> ast.Part

Helper for vector value

virtual 

pub fn virtual(
  builder: QueryBuilder,
  predicate: String,
  args: List(ast.Part),
  outputs: List(String),
) -> QueryBuilder

Query an external data source (Virtual Predicate).

where 

pub fn where(
  builder: QueryBuilder,
  entity: ast.Part,
  attr: String,
  value: ast.Part,
) -> QueryBuilder

Add a where clause (Entity, Attribute, Value).

✨ Search Document