The workhouse query-function constructor will be matching, which returns a function that will match rows with specific column values. You saw how it was used in the earlier examples of select. For instance, this call to matching:

returns a function that matches rows whose :artist value is “Green Day”. You can also pass multiple names and values; the returned function matches when all the columns match. For example, the following returns a closure that matches rows where the artist is “Green Day” and the album is “American Idiot”:

(matching *mp3s* :artist "Green Day" :album "American Idiot")

You have to pass matching the table object because it needs access to the table’s schema in order to get at the equality predicates and value normalizer functions for the columns it matches against.

You then build a list of column-matching functions for the names and values you care about with the following function, :

(defun column-matchers (schema names-and-values)
  (loop for (name value) on names-and-values by #'cddr
       (column-matcher (find-column name schema) value)))

Now you can implement matching. Again, note that you do as much work as possible outside the closure in order to do it only once rather than once per row in the table.

This function is a bit of a twisty maze of closures, but it’s worth contemplating for a moment to get a flavor of the possibilities of programming with functions as first-class objects.

Now recall that the function **EVERY** takes a predicate function as its first argument and returns true if, and only if, that function returns true each time it’s applied to an element of the list passed as **EVERY**‘s second argument. However, in this case, the list you pass to **EVERY** is itself a list of functions, the column matchers. What you want to know is that every column matcher, when invoked on the row you’re currently testing, returns true. So, as the predicate argument to **EVERY**, you pass yet another closure that s the column matcher, passing it the row.

Another matching function that you’ll occasionally find useful is in, which returns a function that matches rows where a particular column is in a given set of values. You’ll define in to take two arguments: a column name and a table that contains the values you want to match. For instance, suppose you wanted to find all the songs in the MP3 database that have names the same as a song performed by the Dixie Chicks. You can write that where clause using in and a subselect like this:4

(select
  :columns '(:artist :song)
  :where (in :song 
             (select
               :columns :song
               :where (matching *mp3s* :artist "Dixie Chicks"))))

Although the queries are more complex, the definition of is much simpler than that of matching.