                                 (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)

           (map second)
           (every? (partial contains? t/single-typemap)))
       (isql/->StaticSqlTemplate
         (isql/make-sql sanitized-st (vec (repeat (count kt-pairs) nil)))
         (make-param-setter (mapv first kt-pairs) (mapv second kt-pairs))
         (make-row-maker result-types)
         (make-column-reader result-types))
       (isql/->DynamicSqlTemplate
         (reduce (fn [st token] (cond
                                  (and (string? token) (string? (last st))) (conj (pop st) (str (last st) token))
                                  (and (vector? token) (string? (last st))

                                (fn [^ResultSet result-set ^long col-index]
                                  (when-not (<= 1 col-index n)
                                    (i/expected s col-index))
                                  (iresult/read-column-value result-set col-index))))
         sql-name           (gensym "sql-name-")}
    :as options}]
  (i/expected vector? "vector of SQL template tokens" sql-template)
  (i/expected vector? "vector of result column types" result-types)
