Clojure:Crie funções dinamicamente a partir de um mapa — Hora de uma macro?

Question

Eu tenho uma função que começa assim:

(defn data-one [suser]
    (def suser-first-name
       (select db/firstNames
            (fields :firstname)
            (where {:username suser})))
    (def suser-middle-name
        (select db/middleNames
            (fields :middlename)
            (where {:username suser})))
    (def suser-last-name
         (select db/middleNames
             (fields :lastname)
             (where {:username suser})))
    ;; And it just continues on and on...
        )

Claro, eu não gosto nada disso.Tenho esse padrão se repetindo em muitas áreas da minha base de código e gostaria de generalizar isso.

Então, pensei no seguinte para começar:

(def data-input {:one '[suser-first-name db/firstNames :firstname] 
                      '[suser-middle-name db/middleNames :middlename]
                      '[suser-last-name db/lastNames :lastname]})

(defpartial data-build [data-item suser]
    ;; data-item takes the arg :one in this case
     `(def (data-input data-item)
        (select (data-input data-item)
            (fields (data-input data-item))
            (where {:username suser}))))

Há realmente algumas perguntas aqui:

- Como posso desconstruir a entrada de dados para que ela crie funções x quando x é desconhecido, ou seja.que os valores de :one são desconhecidos e que as quantidades de chaves na entrada de dados são desconhecidas.

- Estou pensando que este é o momento de criar uma macro, mas nunca construí uma antes, por isso estou hesitante quanto à ideia.

E para dar um pouco de contexto, as funções devem retornar valores para serem desconstruídos, mas acho que assim que eu resolver essa peça, será possível generalizar tudo isso:

(defpage "/page-one" []
    (let [suser (sesh/get :username)]       
    (data-one suser)
        [:p "Firat Name: " 
            [:i (let [[{fname :firstname}] suser-first-name]
                (format "%s" fname))]
        [:p "Middle Name: "  
            [:i (let [[{mname :emptype}] suser-middle-name]
                (format "%s" mname))]
        [:p "Last Name: " 
            [:i (let [[{lname :months}] suser-last-name]
                    (format "%s" lname))]]))

Answer 1

Algumas sugestões:

• def dentro de uma função é realmente desagradável - você está alterando o ambiente global e isso pode causar todos os tipos de problemas de simultaneidade.Eu sugeriria armazenar os resultados em um mapa.
• Você não precisa de uma macro aqui - todas as buscas de dados podem ser feitas com relativa facilidade dentro de uma função

Eu sugeriria, portanto, algo como:

(def data-input [[:suser-first-name db/firstNames :firstname] 
                 [:suser-middle-name db/middleNames :middlename]
                 [:suser-last-name db/lastNames :lastname]])

(def data-build [data-input suser]
  (loop [output {}
         items (seq data-input)]
    (if items
      (recur
        (let [[kw db fieldname] (first items)]
          (assoc output kw (select db (fields fieldname) (where {:username suser})))) 
        (next items))
      output)))

Não testado porque não tenho a configuração do seu banco de dados - mas espero que isso lhe dê uma ideia de como fazer isso sem macros ou globais mutáveis!

Answer 2

Boa pergunta.Primeiro de tudo, aqui está a macro que você pediu:

(defmacro defquery [fname table fields ]
  (let [arg-name (symbol 'user-name)
        fname (symbol fname)]
    `(defn ~fname [~arg-name]
       (print ~arg-name (str ~@ fields)))))

Você pode chamá-lo assim:

(defquery suser-first-name db/firstNames [:firstname])

ou se você preferir manter todas as suas configurações em um mapa, ele aceitará uma string como primeiro argumento em vez de um símbolo:

(defquery "suser-first-name" db/firstNames [:firstname])

---

Agora, se você não se importa que eu recomende outra solução, provavelmente escolheria usar uma única função fechada em torno da configuração.Algo parecido:

(defn make-reader [query-configurations]
  (fn [query-type user-name]
    (let [{table :table field-names :fields} 
           (get query-configurations query-type)]
      (select table
             (apply fields field-names)
             (where {:username suser})))))

(def data-input {:firstname  {:table db/firstNames  :fields :firstname} 
                 :middlename {:table db/middleNames :fields :middlename}
                 :lastname   {:table db/lastNames   :fields :lastname}})

(def query-function (make-reader data-input))

;; Example of executing a query
(query-function :firstname "tom")

A propósito, há outra maneira de usar o Korma:

;; This creates a template select from the table
(def table-select (select* db/firstNames))

;; This creates new select query for a specific field
(def first-name-select (fields table-select :firstname))

;; Creating yet another query that filters results by :username
(defn mkselect-for-user [suser query] 
  (where query {:username suser}))

;; Running the query for username "tom"
;; I fully specified exec function name only to show where it comes from.
(korma.core/exec (mkselect-for-user "tom" first-name-select)) 

Para mais informações eu recomendo fortemente olhar Fontes Korma.