Does .contains works for searching if a string contains a words such as

(.contains "Hello Worlds!" "World")

should, but when in clojure prefer clojure.string/contains?

(:require [clojure.string :as string])

(string/contains? "Hello Worlds!" "World")

My repl seems to not recognize that functions

when was string/contains? added? I don't see it in 1.10.1

Yeah I am using clj 1.10.1

maybe you meant clojure.string/includes?

includes? can work

@contact904 generally javadoc for a type will show you what should work, but clojure often has functions that are more convenient to use

Also, clojure.string is supported in ClojureScript too so you can write portable Clojure/Script using clojure.string functions, whereas the Java interop only works in Clojure.

that's true, the big issue with interop is losing portability

What is the Clojure equivalent for Java's (byte) 255 => -1? (byte 255) returns an error.

@jatkin unchecked-byte

there's a whole family of those

user=> (apropos "unchecked-")
(clojure.core/*unchecked-math* clojure.core/unchecked-add clojure.core/unchecked-add-int clojure.core/unchecked-byte clojure.core/unchecked-char clojure.core/unchecked-dec clojure.core/unchecked-dec-int clojure.core/unchecked-divide-int clojure.core/unchecked-double clojure.core/unchecked-float clojure.core/unchecked-inc clojure.core/unchecked-inc-int clojure.core/unchecked-int clojure.core/unchecked-long clojure.core/unchecked-multiply clojure.core/unchecked-multiply-int clojure.core/unchecked-negate clojure.core/unchecked-negate-int clojure.core/unchecked-remainder-int clojure.core/unchecked-short clojure.core/unchecked-subtract clojure.core/unchecked-subtract-int)

yeah my bad includes?

(defn reduce-over-sql-statement
  "Reduces over the nodes in a sql statement from left to right.
  Will terminate early if the reducing function returns a
  (reduced ...) just like normal reduce."
  [root-sql-statement acc-zero reducing-fn]
  (loop [acc acc-zero
         statement-stack (list root-sql-statement)]
    (if (empty? statement-stack)
      acc
      (let [statement (first statement-stack)
            next-acc-value (reducing-fn acc statement)]
        (cond
          (reduced? next-acc-value)
          @next-acc-value

          (instance? SqlNodeList statement)
          (recur next-acc-value
                 (concat statement statement-stack))

          :else
          (recur next-acc-value
                 (rest statement-stack)))))))

Is there a less manual way to do this?

I don't particuarly understand IReduceInit, but it feels as though there is some way to just hook into the builtin reduce with a tad more logic

@emccue Can you provide a bit more context around what you're trying to do?

I am trying to parse sql scripts and extract the columns and tables that were written to and the ones that were read from

I'm trying to understand your two recur cases -- you're reducing using acc and the top of the statement list in both cases, but if the first element is a SqlNodeList, you're concat'ing the first element to the front of the whole stack which includes that first element???

...that was dumb

yeah, should be a (concat statement (rest ...)))

But then it will reduce on the sql node list and then... reduce on each element of that as well?

I am half translating this https://github.com/intuit/superglue/blob/master/parser/src/main/scala/com/intuit/superglue/pipeline/parsers/CalciteStatementParser.scala

(I'm assuming sql node list behaves like a Clojure list?)

its an iterable, yeah

I am translating this code because calling scalac from leiningen isn't supported and I need some basic parsing to be able to test the rest of what I am working on

and this part here

class Visitor extends SqlBasicVisitor[Unit]

is a class which implements calcite's SqlVisitor interface

which has a bunch of visit methods with different types of arguments, as visitors do

and all SqlBasicVisitor does is auto loop through children of a list node

but I can't actually use that from clojure because proxy isn't up to snuff

and seperate the visitor thing would mandate a bit of local mutability with an atom to translate 1-1

Posting that large a code fragment inline killed my Slack client. You should post a link to code that big 😞

I did post a link

to the superglue one

your client must be configured wierdly

Ah, yes, I removed the expansion of it now.

It auto-expanded the link 😞

I guess your client didn't know to slack off

I don't see SqlNodeList anywhere in that file...?

Nor do I and I am realizing I borked up

https://github.com/apache/calcite/blob/52a57078ba081b24b9d086ed363c715485d1a519/core/src/main/java/org/apache/calcite/sql/util/SqlBasicVisitor.java#L45

I need to do this logic

in my defense it is hard to keep Sql*** stuff straight

...which is more involved since there isn't a straightforward way to remove the mutability

since the actual tree traversing logic seems to be inside of the actual nodes

and not the same in each one

If you walk the tree of nodes, transforming each node into a pair of inputs and outputs, merging them as you go, you'll have no mutability.

A multimethod would probably be the easiest way to handle the transformation?

(since the default could produce [[] []] and you'd only have to implement transforms for the node types that actually have input/output components -- I bet the resulting Clojure code would be a lot shorter than that Scala code)

Hypothetically, yeah

but adapting the acceptCall wouldn't be trivial

and also i don't think that strategy will really work out

at least not that simply

SELECT a.c FROM APPLES a LEFT JOIN BANANAS b WHERE b.id = c.id

This is possibly not valid

but definitely far from the gnarliest sql to be handled

and maybe im not thinking it through enough right now

its too late

Likely what you'll want is to write an evaluator for sql expressions, where the result is the set of selected columns (instead of a sql result set) which would let you do things like check that tables referenced in where clauses are defined in from clauses (the evaluator will build an environment and check that tables mentioned exist in the environment). https://en.m.wikipedia.org/wiki/Abstract_interpretation

(java interop) how do I instantiate a (non-static) inner class in clj? googling, only references I see are for instantiating static nested classes

Is there an idiom like side-effect! but for when you reference an external symbol inside a function.

What do you mean by external symbol?

I realised it would need to be on the actual symbol as well. Like say you have (defonce bucket-name "my-aws-bucket") and you use that throughout your functions in that ns. It would be nice to quickly see what isn’t passed to the function. Like @my-atom is usually a sign. I know my example is not that good because the top level function itself would be a side-effecting one due to aws.

It would make glancing over the functions to see how pure they are faster. Though we could just simply pass it in as a param I guess..

All symbols could be made a parameter 😉

Does anyone have any experience of intercepting java.util.logging log writes? I would like all my logs to go via timbre and I am aware of libraries like slf4j-timbre, but iiuc I am dealing with java.util.logging, not SLF4J and I can't seem to find an equivalent library

I’m trying to access a directory to get a list of files. Conventional knowledge suggests I use (-> ( "absolute/path/to/dir") (file-seq)). While this works normally in dev, it fails once uberjarred because the directory is moved as informed by the classpath. If it were just a file, I would’ve just used (io/resource "relative/path/to/file"), but if it’s a dir I get an exception complaining that the path does not lead to a file. Does anyone have any solution for this?

Maybe something like this would work then

https://calcite.apache.org/apidocs/org/apache/calcite/sql2rel/SqlToRelConverter.html

produce the plan, then just scan through the plan

at least for basic usage

for now the ugly ducking wins

can't reliably reverse the acceptCall logic otherwise

@emccue I have a lightning talk on this from a few years ago: https://www.youtube.com/watch?v=FjKnlzQfAPc

seems like all i need to do is wrap what i have in an IReduceInit

yep that worked

be cooler if that were a protocol but c'est la vie

It already is a protocol

really?

All I see is the concrete interface

which mandates a reify, not an extend-type

you can extend CollReduce if you want a protocol

IReduceInit is helpful if you are making a Java thing

(which has no way to extend a protocol)

IReduceInit is also a better factoring of CollReduce, which has an extra arity without the "init" arg

for all intents and purposes you can treat reduce as an abstraction in Clojure

how do test fixtures compose? I've got a test with multiple fixtures and I don't understand how to call those fixtures with the test manually from the repl. Well, I do, but not multiple fixtures

they are functions, you can use comp

or nest them by hand

there's also a function in clojure.test that runs a test with your fixtures

I can call one fixture from the repl by doing (foo-fixture mytest), and that works fine. But when I try (base-fixture (foo-fixture mytest)) it blows up because foo-fixture doesn't return the test fn

oh, I see compose-fixtures, let me try that

oh, right - my bad clojure.test/compose-fixtures

or you can just use clojure.test/test-var which uses your fixtures iirc

or join-fixtures

cool, join fixtures does exactly what I'm looking for. Thanks!

I'm curious what people's personal guidelines are when it comes to using for vs map.

hi there! is there a way to see the keys for a record in the repl? my colleague @ivanjensen1 is interested in this 😄 for instance we would like to explore the properties of datascript.db.Datom

depends what you mean

user=> (defrecord Foo [a])
user.Foo
user=> (->Foo :a)
#user.Foo{:a :a}
user=> (keys (->Foo :a))
(:a)
user=>

the keys function words on records just like on a map

but you might only be interested in the declared keys that a record must have, not just what keys a particular record object has

the class generated by defrecord has a static method which you can call to get those

user=> (Foo/getBasis)
[a]
user=>

(doc ->Foo) might help as well

oh cool let me try that

thank you folks this is helpful

Is there any consideration about security when I declare a function as private? It is private as it uses a connection to the DB. However, I wanna use this function outside the namespace. Should I wrap it with a public function?

this is my trick for checking keys of a record

user=> (defrecord Bar [a b c])
user.Bar
user=> (keys (map->Bar {}))
(:a :b :c)

i was thinking of a way to find min\max elements and respective indices in a vector and came up with a such contraption, is there a better way?

(def v1 (vec (take 20 (distinct (repeatedly (partial rand-int 100))))))
=> [81 61 13 21 3 98 48 92 72 30 37 2 15 71 34 73 82 50 52 29]
(reduce (fn [acc [idx val :as e]]
            (let [update-fn (fn [v f]
                                (if (f val (peek v))
                                  [idx val]
                                  v))]
              (if (empty? acc)
                [e e]
                (-> acc
                    (update 0 update-fn <=)
                    (update 1 update-fn >=)))))
        [] (map-indexed vector v1))
=> [[11 2] [5 98]]

is the reason that you aren't doing (apply max v1) that you want the index as well?

index aswell

a literal vector would likely be easier to read than two chained updates

you could also use (.indexOf v1 (apply max v1)) to get the index https://stackoverflow.com/questions/4830900/how-do-i-find-the-index-of-an-item-in-a-vector

cljs.user=> (apply max-key second (map-indexed vector [12 78 31]))
[1 78]

that but, use reduce and run max-key and min-key at the same time

@doby162 wouldnt linear search increase complexity? I'm not very proficient with algorithms yet.

thanks guys, that was really helpful, i was looking into max-key but wasn't able to figure it out

(reduce (fn [[min max :as acc] val]
            (if (empty? acc)
              [val val]
              [(min-key second min val) 
               (max-key second max val)]))
        [] (map-indexed vector v1))