```bash
java -jar liquibase-core-3.0.8.jar
     --driver=org.postgresql.Driver
     --changeLogFile=x.xml
     --url="jdbc:postgresql://host:5432/db"
     --classpath=postgresql-9.4.1209.jre7.jar
     --username=postgres
     --password=postgres
     generateChangeLog
```

```clojure
(do
    (require '[medley.core]
             '[clojure.set :as set]
             '[camel-snake-kebab.core :as csk]
             '[clojure.walk]
             '[into-edn :refer [into-edn]]
             '[clojure.zip :as zip]
             '[clojure.data.xml :as xml]
             '[clojure.data.zip.xml :as zf])

    (let [xml-string (slurp "x.xml")
          coerce-map (fn [m] (as-> m a
                                   (medley.core/map-keys csk/->kebab-case a)
                                   (medley.core/map-vals (fn [v] (if (#{"false" "true"} v)
                                                                   (= "true" v)
                                                                   v)) a)
                                   (set/rename-keys a {:nullable :nullable? :primary-key :primary-key? :default-value-boolean :default-value})
                                   (reduce (fn [m [k v]]
                                             (cond-> (assoc m k v)
                                                     (= k :primary-key?) (assoc :unique true :nullable? false)))
                                           {}
                                           a)
                                   (medley.core/remove-keys #{:primary-key-name :deferrable :initially-deferred :on-delete :on-update :disabled} a)))
          coerce-create-index (fn [n] {:create-index (assoc (coerce-map (:attrs n)) :columns (mapv (comp (partial hash-map :column) :attrs) (:content n)))})
          xml-spec
          {:create-table
           [#(zf/xml-> % :changeSet :createTable)
            {:table-name #(-> % zip/node :attrs :tableName)
             :columns
             [#(zf/xml-> % :column)
              {:attrs
               #(-> % zip/node :attrs coerce-map)
               :constraints
               [#(zf/xml-> % :constraints)
                #(-> % zip/node :attrs coerce-map)]}]}]
           :add-foreign-key-constraint
           [#(zf/xml-> % :changeSet :addForeignKeyConstraint)
            #(-> % zip/node :attrs coerce-map)]
           :add-unique-constraint
           [#(zf/xml-> % :changeSet :addUniqueConstraint)
            #(-> % zip/node :attrs coerce-map)]
           :create-index
           [#(zf/xml-> % :changeSet :createIndex)
            #(-> % zip/node coerce-create-index)]}
          zipper (some-> xml-string
                         xml/parse-str
                         zip/xml-zip)
          edn (into-edn xml-spec zipper)
          coerce-create-table (fn [c] {:create-table
                                       (update c :columns
                                               (partial mapv (fn [col]
                                                               {:column
                                                                (cond-> (:attrs col)
                                                                        (seq (:constraints col)) (assoc :constraints (first (:constraints col))))})))})]
      (->>
       {:database-change-log
        [{:change-set
          {:id "bootstrap-0"
           :author "case"
           :changes (concat
                      (->> (:create-table edn) (mapv coerce-create-table))
                      (->> (:add-foreign-key-constraint edn) (mapv (partial hash-map :add-foreign-key-constraint)))
                      (->> (:add-unique-constraint edn) (mapv (partial hash-map :add-unique-constraint)))
                      (:create-index edn)}}]}
       (#(with-out-str (clojure.pprint/pprint %)))
       (spit "changelog.edn")))))
```