Get query's tables and columns

README.md

@@ -11,3 +11,29 @@ Macaw is a limited Clojure wrapper for
 [JSqlParser](https://github.com/JSQLParser/JSqlParser). Similar to its parrot
 namesake, it's intelligent, can be taught to speak SQL, and has many colors
 (supports many dialects).
+
+
+## Building
+
+To build a local JAR, use
+
+```
+clj -T:build jar
+```
+
+This will create a JAR in the `target` directory.
+
+## Working with the Java files
+
+To compile the Java files, use
+
+```
+clj -T:build compile
+```
+
+If you're working on Macaw and make changes to a Java file, you must:
+
+1. Recompile
+2. Restart your Clojure REPL
+
+for the changes to take effect.

build.clj

@@ -0,0 +1,47 @@
+;; Further info: https://clojure.org/guides/tools_build#_mixed_java_clojure_build
+
+(ns build
+  (:require
+   [clojure.java.shell :as sh]
+   [clojure.string :as str]
+   [clojure.tools.build.api :as b]))
+
+(def lib 'metabase/macaw)
+
+(def major-minor-version "0.1")
+
+(defn commit-number []
+  (or (-> (sh/sh "git" "rev-list" "HEAD" "--count")
+          :out
+          str/trim
+          parse-long)
+      "9999-SNAPSHOT"))
+
+(def version (str major-minor-version \. (commit-number)))
+(def target "target")
+(def class-dir (format "%s/classes" target))
+
+(def jar-file (format "target/%s-%s.jar" (name lib) version))
+
+(def basis (delay (b/create-basis {:project "deps.edn"})))
+
+(defn clean [_]
+  (b/delete {:path target}))
+
+(defn compile [_]
+  (b/javac {:src-dirs   ["java"]
+            :class-dir  class-dir
+            :basis      @basis
+            :javac-opts ["--release" "11"]}))
+
+(defn jar [_]
+  (compile nil)
+  (b/write-pom {:class-dir class-dir
+                :lib       lib
+                :version   version
+                :basis     @basis
+                :src-dirs  ["src"]})
+  (b/copy-dir {:src-dirs   ["src" "resources"]
+               :target-dir class-dir})
+  (b/jar {:class-dir class-dir
+          :jar-file  jar-file}))

deps.edn

@@ -1,5 +1,5 @@
 {:paths
- ["src" "resources"]
+ ["src" "java" "resources" "target/classes"]
 
  :deps
  {com.github.jsqlparser/jsqlparser {:mvn/version "4.8"}} ; The actual SQL Parser to wrap!
@@ -41,8 +41,8 @@
   {:deps       {com.github.camsaul/whitespace-linter {:sha "e35bc252ccf5cc74f7d543ef95ad8a3e5131f25b"}}
    :ns-default whitespace-linter
    :exec-fn    whitespace-linter/lint
-   :exec-args  {:paths            ["deps.edn" "src" "test" ".github"]
-                :include-patterns ["\\.clj[cs]?$" "\\.edn$" "\\.yaml$" "\\.md$"]}}
+   :exec-args  {:paths            ["deps.edn" "src" "java" "test" ".github"]
+                :include-patterns ["\\.clj[cs]?$" "\\.edn$" "\\.java$" "\\.yaml$" "\\.md$"]}}
 
   ;; Run tests
   ;;

java/com/metabase/SqlVisitor.java

@@ -0,0 +1,48 @@
+package com.metabase.macaw;
+
+import net.sf.jsqlparser.schema.Column;
+import net.sf.jsqlparser.schema.Table;
+
+/**
+ * Clojure is not good at working with Java Visitors. They require over<em>riding</em> various over<em>loaded</em>
+ * methods and, in the case of walking a tree (exactly what we want to do here) can be counted on to call `visit()`
+ * recursively.
+ *
+ * Clojure's two main ways of dealing with this are `reify`, which does not permit overloading, and `proxy`, which does.
+ * However, creating a proxy object creates a completely new object that does not inherit behavior defined in the parent
+ * class. Therefore, if you have code like this:
+ *
+ * <code>
+     (proxy
+       [TablesNamesFinder]
+       []
+       (visit [visitable]
+         (if (instance? Column visitable)
+           (swap! columns conj (.getColumnName ^Column visitable))
+           (let [^StatementVisitor this this]
+             (proxy-super visit visitable)))))
+   </code>
+
+ * the call to `proxy-super` does <em>not</em> call `TablesNamesFinder.visit()` with the non-`Column` `visitable`; that
+ * definition has been lost.
+ *
+ * <hr>
+ *
+ * Therefore, this interface was created to provide a more convenient escape hatch for Clojure. It removes the
+ * overloading requirement for the conventional visitor pattern, instead providing differently-named methods for each
+ * type. This lets Clojure code use `reify` to implement each method with the necessary behavior. The recursive
+ * tree-walking is handled by a different class, which calls the methods defined here along the way. Think of them as
+ * hooks for Clojure-land that don't affect the main behavior of the visitor.
+ */
+public interface SqlVisitor {
+
+    /**
+     * Called for every `Column` encountered, presumably for side effects.
+     */
+    public void visitColumn(Column column);
+
+    /**
+     * Called for every `Table` encountered, presumably for side effects.
+     */
+    public void visitTable(Table table);
+}