                                 (do
                                   (i/expected vector? "vector of result types" result-types)
                                   (doseq [t result-types]
-                                    (i/expected-result-type t))
+                                    (when-not (contains? t/single-typemap t) (i/expected-result-type t)))
                                   (let [rsyms (-> (count result-types)
                                                 (repeatedly gensym)
                                                 vec)

                               (keyword? token) [token :nil]
                               (vector? token)  (let [[param-key param-type] token]
                                                  (i/expected keyword? "param key (keyword)" param-key)
                                                  (i/expected-param-type param-type)
                                                  token)
                               :otherwise       (i/expected "string, param key or key/type vector" token)))
                       sql-template)]

  [sql-template result-types
   {:keys [make-param-setter
           make-row-maker
           make-column-reader
           sql-name]
    :or {make-param-setter  (fn [param-keys param-types]
                              (eval `(fn [^PreparedStatement prepared-stmt# params#]
                                       (p/lay-params prepared-stmt# ~param-keys ~param-types params#))))
