MAP-QUERY — Map a function over all the tuples from a queryFunction
output-type-specA sequence type specifier or nil.
functionA function designator.
function takes a single argument which
is the atom value for a query single with a single column
or is a list of values for a multi-column query.
query-expressionAn sql expression that represents an SQL query which is expected to return a (possibly empty) result set.
databaseA database object. This will default to the value of *default-database*.
result-types
A field type
specifier. The default is NIL. See query for
the semantics of this argument.
If output-type-spec is a
type specifier other than nil, then a
sequence of the type it denotes. Otherwise
nil is returned.
Applies function to the successive
tuples in the result set returned by executing the SQL
query-expression. If the
output-type-spec is
nil, then the result of each application of
function is discarded, and
map-query returns nil.
Otherwise the result of each successive application of
function is collected in a sequence of
type output-type-spec, where the jths
element is the result of applying
function to the attributes of the jths
tuple in the result set. The collected sequence is the result
of the call to map-query.
If the output-type-spec is a subtype of
list, the result will be a list.
If the result-type is a subtype of
vector, then if the implementation can determine
the element type specified for the
result-type, the element type of the
resulting array is the result of
upgrading that element type; or, if the
implementation can determine that the element type is
unspecified (or *), the element type of the
resulting array is t; otherwise, an error is
signaled.
If result-types is NIL all results
are returned as strings whereas the default value of
:auto means that the lisp types are
automatically computed for each field.
query-expression may be an object query
(i.e., the selection arguments refer to View Classes), in
which case the supplied function is applied to the tuples of
View Class instances returned by the object oriented query.
(map-query 'list #'(lambda (tuple)
(multiple-value-bind (salary name) tuple
(declare (ignorable name))
(read-from-string salary)))
"select salary,name from simple where salary > 8000")
=> (10000.0 8000.5)
(map-query '(vector double-float)
#'(lambda (tuple)
(multiple-value-bind (salary name) tuple
(declare (ignorable name))
(let ((*read-default-float-format* 'double-float))
(coerce (read-from-string salary) 'double-float))
"select salary,name from simple where salary > 8000")))
=> #(10000.0d0 8000.5d0)
(type-of *)
=> (SIMPLE-ARRAY DOUBLE-FLOAT (2))
(let (list)
(values (map-query nil #'(lambda (tuple)
(multiple-value-bind (salary name) tuple
(push (cons name (read-from-string salary)) list))
"select salary,name from simple where salary > 8000"))
list))
=> NIL
=> (("Hacker, Random J." . 8000.5) ("Mai, Pierre" . 10000.0))
(map-query 'vector #'identity
[select [last-name] :from [employee] :flatp t
:order-by [last-name]])
=> #("Andropov" "Brezhnev" "Chernenko" "Gorbachev" "Kruschev" "Lenin" "Putin"
"Stalin" "Trotsky" "Yeltsin")
(map-query 'list #'identity
[select [first-name] [last-name] :from [employee]
:order-by [last-name]])
=> (("Yuri" "Andropov") ("Leonid" "Brezhnev") ("Konstantin" "Chernenko")
("Mikhail" "Gorbachev") ("Nikita" "Kruschev") ("Vladimir" "Lenin")
("Vladimir" "Putin") ("Josef" "Stalin") ("Leon" "Trotsky")
("Boris" "Yeltsin"))
(map-query 'list #'last-name [select 'employee :order-by [emplid]])
=> ("Lenin" "Stalin" "Trotsky" "Kruschev" "Brezhnev" "Andropov" "Chernenko"
"Gorbachev" "Yeltsin" "Putin")
If the execution of the SQL query leads to any errors, an error of type sql-database-error is signalled.
An error of type type-error must
be signaled if the output-type-spec is
not a recognizable subtype of list, not a
recognizable subtype of vector, and not
nil.
An error of type type-error
should be signaled if
output-type-spec specifies the number
of elements and the size of the result set is different from
that number.