Query Reference

'' literal
"" string
[] = list or vector
{} = map {k1 v1 ...}
() grouping
| choice
? zero or one
+ one or more

query             = [find-spec return-map-spec? with-clause? inputs? where-clauses?]
find-spec         = ':find' (find-rel | find-coll | find-tuple | find-scalar)
find-rel          = find-elem+
find-coll         = [find-elem '...']
find-scalar       = find-elem '.'
find-tuple        = [find-elem+]
find-elem         = (variable | pull-expr | aggregate)
variable          = symbol starting with "?"
pull-expr         = ['pull' variable pattern]
pattern           = (pattern-name | pattern-data-literal)
pattern-name      = plain-symbol
plain-symbol      = symbol that does not begin with "$", "?", or "%"
aggregate         = [aggregate-fn-name fn-arg+]
fn-arg            = (variable | constant | src-var)
constant          = any non-variable data literal
src-var           = symbol starting with "$"
return-map-spec   = (return-keys | return-syms | return-strs)
return-keys       = ':keys' plain-symbol+
return-syms       = ':syms' plain-symbol+
return-strs       = ':strs' plain-symbol+
with-clause       = ':with' variable+
inputs            = ':in' (src-var | binding | pattern-name | rules-var)+
binding           = (bind-scalar | bind-tuple | bind-coll | bind-rel)
bind-scalar       = variable
bind-tuple        = [ (variable | '_')+]
bind-coll         = [variable '...']
bind-rel          = = [ [(variable | '_')+] ]
rules-var         = '%'
where-clauses     = ':where' clause+
clause            = (not-clause | not-join-clause | or-clause | or-join-clause | expression-clause)
not-clause        = [ src-var? 'not' clause+ ]
not-join-clause   = [ src-var? 'not-join' [variable+] clause+ ]
or-clause         = [ src-var? 'or' (clause | and-clause)+]
or-join-clause    = [ src-var? 'or-join' [variable+] (clause | and-clause)+ ]
and-clause        = [ 'and' clause+ ]
expression-clause = (data-pattern | pred-expr | fn-expr | rule-expr)
data-pattern      = [ src-var? (variable | constant | '_')+ ]
pred-expr         = [ [pred fn-arg+] ]
fn-expr           = [ [fn fn-arg+] binding]
rule-expr         = [ src-var? rule-name (variable | constant | '_')+]
rule-name         = plain-symbol

See the pull pattern grammar for the description of the pattern-data-literal rule.

Note that the rule grammar reuses some terms from the query grammar above.

rule                       = [ [rule-head clause+]+ ]
rule-head                  = [rule-name rule-vars]
rule-name                  = plain-symbol

This query limits datoms to :artist/name "The Beatles", and returns the entity ids for such results:

(d/q '[:find ?e
       :where [?e :artist/name "The Beatles"]]
     db)

=> #{[26757714973567138]} ;; Result. Your exact value may differ.

Note as well the quoted vector [:find ...]. q requires a quoted sequence passed to it for the query. Failure to quote the query will result in a Unable to resolve symbol: error.

The query below specifies that the result tuples should contain the track name and duration. Note that the ?track and ?e variables are used in the query, but are not returned.

(d/q  '[:find ?name ?duration
        :where [?e :artist/name "The Beatles"]
               [?track :track/artists ?e]
               [?track :track/name ?name]
               [?track :track/duration ?duration]]
       db)

=>
[["Here Comes the Sun" 186000]
 ["Come Together" 257000]
 ["Hey Jude" 428000]
 ...]

In this example, the variable ?track unifies. The clauses for :track/artists, :track/name and :track/duration all must have ?track in the entity slot to unify around the same entity.

Rather than returning just a variable, this query uses a pull expression to specify which attributes to return values for about the entity whose :artist/name is "The Beatles":

(d/q '[:find (pull ?e [:artist/startYear :artist/endYear])
       :where [?e :artist/name "The Beatles"]]
     db)

=>
[[#:artist{:startYear 1957, :endYear 1970}]]

The Pull API provides a declarative interface where you specify what information you want for an entity without specifying how to find it. Pull expressions can be used in queries to find entities and return an explicit map with the specified information about each entity.

This example uses songs-by-artist to find all tracks for an artist, then uses different pull patterns to pull different information about the resulting entities.

(def songs-by-artist
  '[:find (pull ?t pattern)
    :in $ pattern ?artist-name
    :where
    [?a :artist/name ?artist-name]
    [?t :track/artists ?a]])

(def track-releases-and-artists
  [:track/name
   {:medium/_tracks
    [{:release/_media
      [{:release/artists [:artist/name]}
       :release/name]}]}])

;; Pull only the :track/name
(d/q songs-by-artist db [:track/name] "Bob Dylan")

=>
([#:track{:name "California"}]
 [#:track{:name "Grasshoppers in My Pillow"}]
 [#:track{:name "Baby Please Don't Go"}]
 [#:track{:name "Man of Constant Sorrow"}]
 [#:track{:name "Only a Hobo"}]
...)

;; Use a different pull pattern to get the track name, the release name, and the artists on the release.
(d/q songs-by-artist db track-releases-and-artists "Bob Dylan")

=>
([{:track/name "California",
   :medium/_tracks
   #:release{:_media #:release{:artists [#:artist{:name "Bob Dylan"}], :name "A Rare Batch of Little White Wonder"}}]
 [{:track/name "Grasshoppers in My Pillow",
   :medium/_tracks
   #:release{:_media #:release{:artists [#:artist{:name "Bob Dylan"}], :name "A Rare Batch of Little White Wonder"}}]
 [{:track/name "Baby Please Don't Go",
   :medium/_tracks
   #:release{:_media #:release{:artists [#:artist{:name "Bob Dylan"}], :name "A Rare Batch of Little White Wonder"}}]
 [{:track/name "Man of Constant Sorrow",
   :medium/_tracks
   #:release{:_media #:release{:artists [#:artist{:name "Bob Dylan"}], :name "A Rare Batch of Little White Wonder"}}]
 [{:track/name "Only a Hobo",
   :medium/_tracks
   #:release{:_media #:release{:artists [#:artist{:name "Bob Dylan"}], :name "A Rare Batch of Little White Wonder"}}]
 ...)

This query binds ?a ?b ?c ?d, then groups by ?a and ?c, and produces a result for each aggregate expression for each group, yielding 5-tuples.

[:find ?a (min ?b) (max ?b) ?c (sample 12 ?d)
 :where ...]

Each of these is described in more detail below.

The aggregation functions that return a single value are listed below, and all behave as their names suggest.

Where n is specified, fewer than n items may be returned if not enough items are available.

Most queries operate against a single database. So as a convenience, the inputs clause can be elided, and will default to a single database whose name is the dollar sign $.

For example, the following three queries are equivalent:

;; with only $ as input, the :in clause can be dropped
[:find ?e
:where [?e :age ?age]]

;; use the shorter name $, which can be omitted from where clauses
[:find ?e
:in $ ?age
:where [?e :age ?age]]

;; use $data to name the database
[:find ?e
:in $data ?age
:where [$data ?e :age ?age]]

The query below takes the artist name as an input, so that this parameterized query can be re-used with different artist names.

Inside the query, $ is bound to db, and ?name is bound to "The Beatles".

(d/q '[:find (pull ?e [:artist/startYear :artist/endYear])
       :in $ ?name
       :where [?e :artist/name ?name]]
      db "The Beatles")

=> [[#:artist{:startYear 1957, :endYear 1970}]]

An input can be a pattern var, specifying a pattern to be used in pull expressions in the find clause.

The query below binds pattern to the artist's start year and end year.

(d/q '[:find (pull ?e pattern)
       :in $ ?name pattern
       :where [?e :artist/name ?name]]
     db "The Beatles" [:artist/startYear :artist/endYear]) 

=> [[#:artist{:startYear 1957, :endYear 1970}]]

bind-tuple                 = [ (variable | '_')+]

A tuple binding binds a set of variables to a single value each, passed in as a collection. The query below binds both artist name and release name to find the entity ids for releases of John Lennon's Mind Games:

(d/q '[:find ?release
       :in $ [?artist-name ?release-name]
       :where [?artist :artist/name ?artist-name]
              [?release :release/artists ?artist]
              [?release :release/name ?release-name]]
     db ["John Lennon" "Mind Games"])

=>
#{[17592186157686]
  [17592186157672]
  [17592186157690]
  [17592186157658]}

bind-coll                  = [variable '...']

A collection binding binds a single variable to multiple values passed in as a collection. This can be used to ask "or" questions involving the values of the collection binding.

This query shows how to ask "What releases are associated with either Paul McCartney or George Harrison?"

(d/q '[:find ?release-name
        :in $ [?artist-name ...]
        :where [?artist :artist/name ?artist-name]
               [?release :release/artists ?artist]
               [?release :release/name ?release-name]]
     db ["Paul McCartney" "George Harrison"])

=>
#{["My Sweet Lord"]
  ["Electronic Sound"]
  ["Give Me Love (Give Me Peace on Earth)"]
  ["All Things Must Pass"]
  ...}

bind-rel                   = [ [(variable | '_')+] ]

A relation binding is fully general, binding multiple variables positionally to a relation (collection of tuples) passed in. This can be used to ask "or" questions involving variables in the relation binding. For example, what releases are associated with either John Lennon's Mind Games or Paul McCartney's Ram?

(d/q '[:find ?release
       :in $ [[?artist-name ?release-name]]
       :where [?artist :artist/name ?artist-name]
              [?release :release/artists ?artist]
              [?release :release/name ?release-name]]
     db [["John Lennon" "Mind Games"]
         ["Paul McCartney" "Ram"]]) 

=>
#{[17592186157686]
  [17592186157672]
  [17592186157690]
  [17592186157658]
  [17592186063566]}

In data patterns, you should elide any trailing components you don't care about, rather than explicitly padding with blanks. The previous examples already demonstrates this by omitting the Tx and Op components from the pattern

;; unnecessary trailing blanks
[_ :artist/name ?name _ _] 

;; better
[_ :artist/name ?name] 

The query below uses the built-in predicates <= and < to limit the results to artists whose name sorts greater than or equal to "Q" and less than "R", i.e. the artists whose name begins with "Q":

(d/q '[:find ?name
       :where [_ :artist/name ?name]
              [(<= "Q" ?name)]
              [(< ?name "R")]]
     db)

=>
[["Quiet World"]
 ["Queen"]
 ["Quintessence"]
 ...]

You can use any pure function from the clojure.core namespace as a predicate.

The predicates =, !=, <=, <, >, and >= are special, in that they take direct advantage of Datomic's AVET index. This makes them much more efficient than equivalent formulations using ordinary predicates. For example, the "artists whose name starts with 'Q'" query shown above is much more efficient than an equivalent version using starts-with?

;; fast -- uses AVET index
[(<= "Q" ?name)]
[(< ?name "R")]

;; slower -- must consider every value of ?name
[(clojure.string/starts-with? ?name "Q")]

Unlike their Clojure equivalents, the Datomic range predicates require exactly two arguments.

The section Built-in Predicates and Functions lists all built-in predicates.

The example below uses the division function quot call to convert track lengths from milliseconds to minutes:

(d/q '[:find ?track-name ?minutes
       :in $ ?artist-name
       :where [?artist :artist/name ?artist-name]
              [?track :track/artists ?artist]
              [?track :track/duration ?millis]
              [(quot ?millis 60000) ?minutes]
              [?track :track/name ?track-name]]
     db "John Lennon")

=>
#{["Crippled Inside" 3] 
  ["Working Class Hero" 3] 
  ["Sisters, O Sisters" 3] 
  ["Only People" 3] 
  ...}

An alternate example utilizing a predicate with a function binding to find artists with names under 7 characters and show the number of characters in their name.

(d/q '[:find ?name ?count
       :where [_ :artist/name ?name]
              [(<= "Q" ?name)] 
              [(count ?name) ?count]
              [(< ?count 7)]]
db)

=>
[["井上陽水" 4]
 ["Spring" 6]
 ["頭脳警察" 4]
 ["Sonoma" 6]
 ["Selda" 5]
 ["Tony" 4]
 ["Smile" 5]
 ["Sun Ra" 6]
 ...]

The section Built-in Predicates and Functions lists all built-in functions.

[(get-else src-var ent attr default) ?val-or-default]

The get-else function takes a database, an entity identifier, a cardinality-one attribute, and a default value. It returns that entity's value for the attribute, or the default value if entity does not have a value.

The query below reports "N/A" whenever an artist's startYear is not in the database:

(d/q '[:find ?artist-name ?year
       :in $ [?artist-name ...]
       :where [?artist :artist/name ?artist-name]
              [(get-else $ ?artist :artist/startYear "N/A") ?year]]
     db ["Crosby, Stills & Nash" "Crosby & Nash"]) 

=>
#{["Crosby, Stills & Nash" 1968] 
  ["Crosby & Nash" "N/A"]}

[(get-some src-var ent attr+) [?attr ?val]]

The get-some function takes a database, an entity identifier, and one or more cardinality-one attributes, returning a tuple of the entity id and value for the first attribute possessed by the entity.

The query below tries to find a :country/name for an entity, and then falls back to :artist/name:

(d/q '[:find ?e ?attr ?name
       :in $ ?e
       :where [(get-some $ ?e :country/name :artist/name) [?attr ?name]]]
      db :country/US)

=> [:country/US 84 "United States"]

[(ground const) binding]

The ground function takes a single argument, which must be a constant, and returns that same argument. Programs that know information at query time should prefer ground over e.g. identity, as the former can be used inside the query engine to enable optimizations.

[(ground [:a :e :i :o :u]) [?vowel ...]]

[(missing? src-var ent attr)]

The missing? predicate takes a database, an entity identifier, and an attribute and returns true if the entity has no value for attribute in the database.

The following query finds all artists whose start year is not recorded in the database.

(d/q '[:find ?name
       :where [?artist :artist/name ?name]
              [(missing? $ ?artist :artist/startYear)]]
     db)

=>
#{["Sigmund Snopek III"]
  ["De Labanda's"]
  ["Baby Whale"]
  ...}

The q function allows you to perform nested queries, and takes the same arguments as the variable-arity q api function.

The example below shows using a nested query to bind the the ?duration variable for use by an enclosing query that returns the entity id and name of the shortest tracks:

(d/q '[:find ?track ?name ?duration
       :where
       [(q '[:find (min ?duration)
             :where [_ :track/duration ?duration]]
           $) [[?duration]]]
       [?track :track/duration ?duration]
       [?track :track/name ?name]]
     db)

=>
[[8334298138708635 "Nutopian International Anthem" 3000]
 [9007199254790299 "Nutopian International Anthem" 3000]]

[(tuple ?a ...) ?tup]

Given one or more values, the tuple function returns a tuple containing each value. See also untuple.

(d/q '[:find ?tup
       :in ?a ?b
       :where [(tuple ?a ?b) ?tup]]
     1 2)

=> #{[[1 2]]}

[(untuple ?tup) [?a ?b]]

Given a tuple, the untuple function can be used to name each element of the tuple. See also tuple.

(d/q '[:find ?b
       :in ?tup
       :where [(untuple ?tup) [?a ?b]]]
     [1 2])

=> #{[2]}

Java static methods can be called with the (ClassName/methodName …) form. For example, the following code calls System.getProperties, binding property names to ?k and property values to ?v.

(d/q '[:find ?k ?v
       :where [(System/getProperties) [[?k ?v]]]]

=>
#{["java.vendor.url.bug" "http://bugreport.sun.com/bugreport/"] 
  ["sun.cpu.isalist" ""] 
  ["sun.jnu.encoding" "UTF-8"]
  ...}

Java instance methods can be called with the (.methodName obj …) form. For example, the following code finds artists whose name contains "woo"?

(d/q '[:find ?name
       :where [_ :artist/name ?name]
              [(.contains ^String ?name "woo")]]
     db)

=>
[["Lee Hazlewood"] ["Cottonwood"] ["Chris Harwood"] ["Mirkwood"]
 ["Under Milkwood"] ["Dorothy Norwood"] ["Fleetwood Mac"]]

Note the ^String type hint on ?name. Type hints outside java.lang will need to be fully qualified, and complex method signatures may require more than one hint to be unambiguous.

The following query uses a not clause to find the count of all artists who are not Canadian:

(d/q '[:find (count ?eid)
       :where [?eid :artist/name]
              (not [?eid :artist/country :country/CA])]
     db)

=> [[4538]]

Not clauses are evaluated like a subquery and return a set of tuples that is used to remove tuples from the query's result set via set difference. Since the removal of tuples from the query's result set is performed using set logic, not clauses have the potential to be much more efficient than expression predicates which must be applied iteratively to each tuple in the result set instead of to the entire result set.

All variables used in a not clause will unify with the surrounding query. This includes both the arguments to nested expression clauses as well as any bindings made by nested function expressions. Datomic will attempt to push the not clause down until all necessary variables are bound, and will throw an ::anom/incorrect anomaly if that is not possible.

The query below demonstrates the problem. It attempts to remove eids that are not associated with an :artist/country, without ever finding a set of eids to begin with:

(d/q '[:find (count ?eid)
       :where (not [?eid :artist/country :country/CA])]
     db)

(ex-data *e)

=> {:cognitect.anomalies/category :cognitect.anomalies/incorrect,
 :cognitect.anomalies/message "[?eid] not bound in not clause: (not-join [?eid] [?eid :artist/country :country/CA])",
 :db/error :db.error/insufficient-binding}

In this next query, which returns the number of artists who didn't release an album in 1970, ?artist is in the var clause and must unify with the surrounding query. ?release is used only inside the not-join clause and will not unify.

(d/q '[:find (count ?artist)
       :where [?artist :artist/name]
              (not-join [?artist]
                        [?release :release/artists ?artist]
                        [?release :release/year 1970])]
     db)

=> [[3263]]

When more than one clause is supplied to not or not-join, they are evaluated as if connected by an and clause.

The following query counts the number of releases named "Live at Carnegie Hall" that were not by Bill Withers.

(d/q '[:find (count ?r)
       :where [?r :release/name "Live at Carnegie Hall"]
              (not-join [?r]
                        [?r :release/artists ?a]
                        [?a :artist/name "Bill Withers"])]
     db)

=> [[2]]

All clauses used in an or clause must use the same set of variables, which will unify with the surrounding query. This includes both the arguments to nested expression clauses as well as any bindings made by nested function expressions. Datomic will attempt to push the or clause down until all necessary variables are bound, and will throw an exception if that is not possible.

One can imagine or clauses turn into an invocation of an anonymous rule whose predicates comprise the or clauses. As with rules, src-vars are not currently supported within the clauses of or, but are supported on the or clause as a whole at top level.

The following query uses an and clause inside the or clause to find the number of artists who are either groups or females:

(d/q '[:find (count ?artist)
       :where (or [?artist :artist/type :artist.type/group]
                  (and [?artist :artist/type :artist.type/person]
                       [?artist :artist/gender :artist.gender/female]))]
     db)

=> [[2323]]

In this query, which returns the number of releases that are either by Canadian artists or released in 1970, ?artist is only used inside the or clause and doesn't need to unify with the outer clause. or-join is used to specify that only ?release needs unifying.

(d/q '[:find (count ?release)
       :where [?release :release/name]
              (or-join [?release]
                       (and [?release :release/artists ?artist]
                            [?artist :artist/country :country/CA])
                       [?release :release/year 1970])]
     db)

=> [[2124]]

Consider the following example, where our intention is to find out the years of every Bob Dylan release.

;; incorrect query
(d/q '[:find ?year
       :where [?artist :artist/name "Bob Dylan"]
              [?release :release/artists ?artist]
              [?release :release/year ?year]]
   db)

=> [[1969] [1970] [1971] [1973] [1968]]

Bob Dylan was clearly a more prolific artist than this. The query returned the years Bob Dylan released records, rather than the release years of each of the records.

Set logic combines all of the releases that came out in the same year, and this is not what is wanted for the particular query.

A with-clause correct this query:

;; fixed query
(d/q '[:find ?year
       :with ?release
       :where [?artist :artist/name "Bob Dylan"]
              [?release :release/artists ?artist]
              [?release :release/year ?year]]
     db) 

=> [[1973] [1971] [1973] [1973] [1970] [1968] [1971] [1969] [1968] [1970] [1973] [1970] [1971] [1970] [1973] [1968] [1971] [1973] [1970] [1969] [1971] [1970]]

This result is more like what we wanted. This is a list of the year of each release between 1968 and 1973.

rule                       = [ [rule-head clause+]+ ]
rule-head                  = [rule-name rule-vars]
rule-name                  = plain-symbol
rule-vars                  = [variable+ | ([variable+] variable*)]

As with transactions and queries, rules are described using data structures. A rule is a list of lists. The first list in the rule is the rule-head. It names the rule and specifies its rule-vars. The rest of the lists are clauses that make up the body of the rule.

In the example below, the rule-head is track-info, and the three clauses of the rule body join artists to name and duration information about tracks:

[(track-info ?artist ?name ?duration)
 [?track :track/artists ?artist]
 [?track :track/name ?name]
 [?track :track/duration ?duration]]

inputs                     = ':in' (src-var | binding | pattern-name | rules-var)+
rules-var                  = the symbol "%"
rule-expr                  = [ src-var? rule-name (variable | constant | '_')+]

You have to do two things to use a rule in a query. First, you have to pass a rule set (collection of rules) as an input source and reference it in the :in section of your query using the '%' symbol. Second, you have to invoke one or more rules with a rule-expr in the :where section of your query.

The example below puts the track-info rule into a collection and names the rules with %. It then invokes the rule track-info by name in the where clause:

(def rules
  '[[(track-info ?artist ?name ?duration)
     [?track :track/artists ?artist]
     [?track :track/name ?name]
     [?track :track/duration ?duration]]])

(d/q '[:find ?name ?duration
       :in $ % ?aname
       :where [?artist :artist/name ?aname]
              (track-info ?artist ?name ?duration)]
     db rules "The Beatles")

=> 
[["Here Comes the Sun" 186000] 
 ["Hey Jude" 428000] 
 ["Come Together" 257000]
 ...]

Rules with multiple definitions will evaluate them as different logical paths to the same conclusion (i.e. logical OR). In the rule below, the rule name benelux is defined three times. As a result, the rule matches artists from any of the three Benelux countries:

(def rules
  '[[(benelux ?artist)
     [?artist :artist/country :country/BE]]
    [(benelux ?artist)
     [?artist :artist/country :country/NL]]
    [(benelux ?artist)
     [?artist :artist/country :country/LU]]])

(d/q '[:find ?name
       :in $ %
       :where (benelux ?artist)
              [?artist :artist/name ?name]]
     db rules)

=>
[["Earth and Fire"]
 ["André Brasseur"]
 ["Nico Gomez & His Afro Percussion Inc."]
  ...]

Rules normally operate exactly like other items in a where clause. They must unify with the variables already bound, and must bind any variables not already bound.

But sometimes you know that a rule will only be correct, or only be efficient, if some variables are already bound. You can require that some variables be bound before a rule can fire by enclosing the required variables in a vector or list as the first argument to the rule. If the required variables are not bound, Datomic will report an incorrect anomaly.

In the example below, the track-info rule has ?artist as a required binding, and a query that does not bind ?artist fails:

(def rules
  '[[(track-info [?artist] ?name ?duration)
     [?track :track/artists ?artist]
     [?track :track/name ?name]
     [?track :track/duration ?duration]]])

(d/q '[:find ?artist ?name ?duration
       :in $ %
       :where (track-info ?artist ?name ?duration)]
     db rules)

(ex-data *e)

=> 
{:cognitect.anomalies/category :cognitect.anomalies/incorrect,
 :cognitect.anomalies/message "[?artist] not bound in clause: (track-info ?artist ?name ?duration)",
 :db/error :db.error/insufficient-binding}

This can be fixed easily:

(def rules
  '[[(track-info [?artist] ?name ?duration)
     [?track :track/artists ?artist]
     [?track :track/name ?name]
     [?track :track/duration ?duration]]])

(d/q '[:find ?artist ?name ?duration
       :in $ %
       :where [?artist :artist/name "The Rolling Stones"]
              (track-info ?artist ?name ?duration)]
     db rules)

=>
[[62821696364619130 "Sittin’ on a Fence" 184040]
 [62821696364619130 "2000 Light Years From Home" 287000]
 [62821696364619130 "Jumpin' Jack Flash" 242066]
 [62821696364619130 "What to Do" 158000] ...]

rule-expr                  = [ src-var? rule-name (variable | constant | '_')+]

By default, rules operate against the default database named by $. As with other where clauses, you may specify a database as a src-var before the rule-name to scope the rule to that database. Databases cannot be used as arguments in a rule.

The example below passes in two sources: the $mbrainz database, and an $artists relation. Every where clause must therefore begin with a src-var name:

(def rules
  '[[(track-info [?artist] ?name ?duration)
     [?track :track/artists ?artist]
     [?track :track/name ?name]
     [?track :track/duration ?duration]]])

(d/q '[:find ?name ?duration
       :in $mbrainz $artists %
       :where [$artists ?aname]
              [$mbrainz ?artist :artist/name ?aname]
              ($mbrainz track-info ?artist ?name ?duration)]
     db [["The Beatles"]] rules)

=>
[["Here Comes the Sun" 186000]
 ["Come Together" 257000]
 ["Hey Jude" 428000]
...]

In all the examples above, the body of each rule is made up solely of data clauses. However, rules can contain any type of clause that a where clause might contain: data, expressions, or even other rule invocations.

Next: Pull