                                data references))
         transform-keys (if keyfn
                          (partial map #(convert-keys % keyfn))
-                         identity)]
+                         identity)
+        remove-nils (fn [data]
+                      (map
+                       (fn [row]
+                         (into {} (remove (fn [[k v]] (nil? v)) row)))
+                       data))]
     (doseq [file sources]
       (load-csv-file
        (str dir "/" file)
        collection
-       (comp transform-keys add-concepts cast-data)))))
+       (comp remove-nils transform-keys add-concepts cast-data)))))
 
 (defmulti load-slice
   (fn [slice _ definition]

        (r/remove nil?
                  (r/map (fn [[column value]]
                           (let [cdef (columns column)]
                             (when (and (seq cdef) (not (:skip cdef)))
                               [(keyword (or (:name cdef) column))
                                (cast-value value cdef)]))) data))))


   :default true))

(defmethod cast-value "date" [value {:keys [format]}]
  (cond
   (str/blank? value) nil
   format (time/parse (time/formatter format) value)
   :default (time/parse default-date-parser value)))

(defmethod cast-value "lookup" [value {:keys [lookup]}]
  ;; Have to call keyword on value because Cheshire turns keys into keywords
  (when-not (str/blank? value)
    (lookup (keyword value))))

(defmethod cast-value :default [value _]
  value)
