edn-query-language.core — space.matterandvoid/eql 2023.11.21

*shallow-conversion* clj/s

Dynamic var. When bound to true in the current thread, calls to query->ast will not go past the first level of children. This is useful when you just want the AST for one layer of a query.

ast->expr clj/s

(ast->expr ast)

(ast->expr {:keys [type component] ast-meta :meta :as ast} unparse?)

Given a query expression AST convert it back into a query expression.

ast->query clj/s

(ast->query query-ast)

call->ast clj/s

(call->ast [f args :as call])

expr->ast clj/s

(expr->ast x)

Given a query expression convert it into an AST.

focus-subquery clj/s

(focus-subquery query sub-query)

Given a query, focus it along the specified query expression.

Examples: (focus-query [:foo :bar :baz] [:foo]) => [:foo]

(fulcro.client.primitives/focus-query [{:foo [:bar :baz]} :woz] [{:foo [:bar]} :woz]) => [{:foo [:bar]} :woz]

focus-subquery* clj/s

(focus-subquery* query-ast sub-ast)

Internal implementation of focus-subquery, you can use this function directly if you want to send AST in and get AST out (instead of query in / query out).

focus-subquery-union* clj/s

(focus-subquery-union* query-ast sub-ast)

ident->ast clj/s

(ident->ast [k id :as ref])

ident? clj/s

(ident? x)

Check if x is a EQL ident.

join->ast clj/s

(join->ast join)

keyword->ast clj/s

(keyword->ast k)

mask-query clj/s

(mask-query source mask)

Given a source EQL query, use a mask EQL query to filter which elements to pick from the source. Params will be maintaned from the source, params in mask are ignored.

mask-query* clj/s

(mask-query* {:keys [children] :as source-ast} mask-ast)

merge-asts clj/s

(merge-asts)

(merge-asts q)

(merge-asts qa qb)

Merges two ast's.

merge-queries clj/s

(merge-queries qa qb)

Merges two queries

normalize-query-variables clj/s

(normalize-query-variables query)

Converts ident values and param values to ::p/var.

parameterize clj/s

(parameterize expr params)

query->ast clj/s

(query->ast query)

Convert a query to its AST representation.

query->ast1 clj/s

(query->ast1 query-expr)

Call query->ast and return the first children.

query->shallow-ast clj/s

(query->shallow-ast query)

Like query->ast, but does not follow joins. Useful for efficiently getting just the top-level entries in a large query.

query-id clj/s

(query-id query)

Generates a consistent hash from the query. The query first goes to a process to remove any variables from idents and params, then we get the Clojure hash of it. You can use this to save information about a query that can be used to correlate with the query later.

symbol->ast clj/s

(symbol->ast k)

transduce-children clj/s

(transduce-children xform {:keys [children] :as node})

Recursivelly transduce children on the AST, you can use this to apply filter/transformations on a whole AST. Each iteration of the transducer will get a single AST node to process.

(->> [:a {:b [:c :d]} :e]
     (p/query->ast)
     (p/transduce-children (remove (comp #{:a :c} :key)))
     (p/ast->query))
; => [{:b [:d]} :e]

union->ast clj/s

(union->ast m)

union-children? clj/s

(union-children? ast)

Given an AST point, check if the children is a union query type.

union-entry->ast clj/s

(union-entry->ast [k v])

update-child clj/s

(update-child ast key & args)

Given an AST, find the child with a given key and run update against it.

update-property-param clj/s

(update-property-param x f & args)

Add property param, eg:

(p/update-property-param :keyword assoc :foo "bar") => (:keyword {:foo "bar"})
(p/update-property-param '(:keyword {:param "prev"}) assoc :foo "bar") => (:keyword {:foo "bar" :param "prev"})

update-recursive-depth clj/s

(update-recursive-depth ast key & args)

Given an AST, find the child with a given key and run update against it.

wrap-expr clj/s

(wrap-expr root? expr)