Hi all, I am Tuukka from Finland. Nice to meet you all! I have 2 weeks of experience with Clojure (total noob!) and was wondering good tools/frameworks for connecting Mysql database to Clojure. At the moment I am using jdbc for the connection. All tips and suggestions are appreciated. Thanks a lot for accepting me to this community! Ps. Apologies if I am posting question to wrong thread 🙂

JDBC is the standard. You might consider also using https://github.com/jkk/honeysql for nicer query-syntax, it's a pretty common lib.

(def sqlmap {:select [:a :b :c]
             :from [:foo]
             :where [:= :f.a "baz"]})

Or HugSQL, if you’re already familiar/comfortable with SQL. https://www.hugsql.org/

If you're looking for "opinionated backend" frameworks & not just a SQL driver we can recommend something there, but it'll probably still use JDBC if talking to a SQL database 🙂

@info293 assuming you mean clojure.java.jdbc instead of using jdbc directly

Have to say that I'm very impressed to get this many answers in such short time. Thank you for making me feel welcome right away. You rule!

@info293 Welcome! clojure.java.jdbc is very stable and has been around for years but all future work has moved to https://github.com/seancorfield/next-jdbc in case you feel like using the "next generation" JDBC library. I think the documentation is better (even if I do say so myself!). I'll still support clojure.java.jdbc (and I regularly answers questions about it in #sql ) but I'm trying to encourage folks who are starting new projects to use next.jdbc instead.

im doing this

(defn stringify-map-keys [my-map]
  ((zipmap ((map name (keys my-map)) (vals my-map)))))

(deftest stringify-map-keys
  (is (=
       (stringify-map-keys {:a "hi"})
       {"a" "hi"})))

deftest declares a function with the same name, and running the test calls it. Best not to use same name for deftest as an ordinary function. Common practice is to have test- as prefix of deftest name or -test as suffix.

oh wow, okay, it's me thats stupid haha

thanks a lot

@lkowarschick there is another arity exception I'd assume you'd see after that, thanks to extra parens

not stupid at all. It is pretty subtle, and probably bites several people the first time they use deftest.

I guess you'd get the "can't call a lazy-seq" error before that though, because of yet another set of extra parens

@lkowarschick generally parens aren't "free" in clojure, and don't just do grouping (the exceptions to this are very rare)

yea that extra parens are just bad copy pasting ;D

Or another way of phrasing it, unlike C/Java-like syntax languages, every set of parens has significance. There are no "redundant" ones you can add in without changing the meaning, whereas in C/Java-like languages, you can throw in extra parens in math expressions with no effect.

@andy.fingerhut I really wanted to say it in that sweeping a way, but there's at least one exception where parens do just do grouping :D

I'm not thinking of it. What case are you thinking of?

(case x 1 :one) (case x (1) :one) are identical in meaning

Right.

I thought there was another one but I'm not remembering it off hand

Even there, it is because of case special handling of lists of constants. You can't add a second set of parens around that without changing the meaning.

that's true

I guess inside ->, similarly, you get exactly one free set of optional parens on each subform after the first

(as long as it has no args)

C/Java/etc (((((5))))) means exactly the same thing as 5 in arithmetic expressions.

right, there's nothing in clojure that allows nested free parens, just individual contexts where one set of parens can be skipped optionally

how would you pick 4 random entries of a set that had 9 things?

4 random entries from a set that has 5 or more things, how about.

(take 4 (shuffle s))

hot peppers

that was fast

you're hired

that's if you don't want duplicates of course :D

correct no dupes

it is a #{set}

right - but for some algorithms you want N fair choices from a set, even if you get one item twice

for that you want (repeatedly 4 #(rand-nth (seq s)))

one of the rare cases you need to call seq explicitly and it's not for nil checking

in this circumstance i strongly want to avoid duplicates

thank you 🙂

math.combinatorics has good (lazy!) answers for these kinds of things

https://github.com/clojure/math.combinatorics