Upgraded jdbc from 0.3.3 to 0.6.1

project.clj

@@ -1,21 +1,17 @@
 (defproject lobos "1.0.0-beta3"
-  :description
-  "A library to create and manipulate SQL database schemas."
+  :description "A library to create and manipulate SQL database schemas."
   :url "http://budu.github.com/lobos/"
   :license {:name "Eclipse Public License"}
-  :dependencies [[org.clojure/clojure "1.4.0"]
-                 [org.clojure/java.jdbc "0.3.3"]
-                 [org.clojure/tools.macro "0.1.2"]]
-  :profiles {:1.3 {:dependencies [[org.clojure/clojure "1.3.0"]]}
-             :1.5 {:dependencies [[org.clojure/clojure "1.5.0"]]}
-             :dev
+  :dependencies [[org.clojure/clojure "1.8.0"]
+                 [org.clojure/java.jdbc "0.6.1"]
+                 [org.clojure/tools.macro "0.1.5"]]
+  :profiles {:dev
              {:dependencies
-              [[lein-clojars "0.7.0"]
-               [lein-marginalia "0.6.1"]
+              [[lein-clojars "0.9.1"]
+               [lein-marginalia "0.9.0"]
                [lein-multi "1.1.0"]
                [cljss "0.1.1"]
-               [hiccup "0.3.1"]
-               [com.h2database/h2 "1.3.160"]]}}
-  :aliases {"all" ["with-profile" "dev:dev,1.3"]}
+               [hiccup "1.0.5"]
+               [com.h2database/h2 "1.4.193"]]}}
   :jar-exclusions [#"www.clj" #"config.clj" #"migrations.clj"]
   :min-lein-version "2.0.0")

src/lobos/analyzer.clj

@@ -9,12 +9,12 @@
 (ns lobos.analyzer
   "Analyze a database's meta-data to contruct an abstract schema."
   (:refer-clojure :exclude [defonce replace])
-  (:require (lobos [connectivity :as conn]
-                   [schema :as schema]))
-  (:use (clojure [string :only [replace]])
-        lobos.internal
-        lobos.metadata
-        lobos.utils)
+  (:require [clojure.string :as string :refer [replace]]
+            (lobos ;; [connectivity :as conn]
+             [internal :as internal :refer :all]
+             [metadata :as metadata] ;;  :refer :all]
+             [schema :as schema]
+             [utils :refer :all]))
   (:import (java.sql DatabaseMetaData)
            (lobos.schema Column
                          DataType
@@ -43,7 +43,7 @@
   (fn [dispatch-val & args]
     (if (vector? dispatch-val)
       dispatch-val
-      [(as-keyword (.getDatabaseProductName (db-meta)))
+      [(as-keyword (.getDatabaseProductName (metadata/db-meta)))
        dispatch-val]))
   :hierarchy db-hierarchy)
 
@@ -71,7 +71,7 @@
 
 (defmethod analyze [::standard UniqueConstraint]
   [_ sname tname cname index-meta]
-  (let [pkeys (primary-keys sname tname)]
+  (let [pkeys (metadata/primary-keys sname tname)]
     (UniqueConstraint.
      (keyword cname)
      (if (pkeys (keyword cname))
@@ -112,14 +112,14 @@
   [_ sname tname]
   (concat
    (map (fn [[cname meta]] (analyze UniqueConstraint sname tname cname meta))
-        (indexes-meta sname tname #(let [nu (:non_unique %)]
-                                     (or (false? nu) (= nu 0)))))
+        (metadata/indexes-meta sname tname #(let [nu (:non_unique %)]
+                                              (or (false? nu) (= nu 0)))))
    (map (fn [[cname meta]] (analyze ForeignKeyConstraint cname meta))
-        (references-meta sname tname))))
+        (metadata/references-meta sname tname))))
 
 (defmethod analyze [::standard Index]
   [_ sname tname iname index-meta]
-  (let [pkeys (primary-keys sname tname)]
+  (let [pkeys (metadata/primary-keys sname tname)]
     (Index.
      (keyword iname)
      tname
@@ -131,7 +131,7 @@
 (defmethod analyze [::standard :indexes]
   [_ sname tname]
   (map (fn [[iname meta]] (analyze Index sname tname iname meta))
-       (indexes-meta sname tname)))
+       (metadata/indexes-meta sname tname)))
 
 (defn analyze-data-type-args
   "Returns a vector containing the data type arguments for the given
@@ -172,29 +172,31 @@
   (schema/table* tname
                  (into {} (map #(let [c (analyze Column %)]
                                   [(:cname c) c])
-                               (columns-meta sname tname)))
+                               (metadata/columns-meta sname tname)))
                  (into {} (map #(vector (:cname %) %)
                                (analyze :constraints sname tname)))
                  (into {} (map #(vector (:iname %) %)
                                (analyze :indexes sname tname)))))
 
 (defmethod analyze [::standard Schema]
   [_ sname]
-  (apply schema/schema sname {:db-spec (db-meta-spec)}
+  (apply schema/schema sname {:db-spec (metadata/db-meta-spec)}
          (map #(analyze Table sname %)
-              (tables sname))))
+              (metadata/tables sname))))
 
 (defn analyze-schema
   [& args]
   {:arglists '([connection-info? sname?])}
-  (let [[db-spec sname _] (optional-cnx-and-sname args)]
-    (with-db-meta db-spec
-      (autorequire-backend db-spec)
+  (let [[db-spec sname _] (internal/optional-cnx-and-sname args)]
+    (metadata/with-db-meta db-spec
+      (internal/autorequire-backend db-spec)
       (let [sname (or (keyword sname)
-                      (default-schema)
-                      (first _))]
-        (if-let [schemas (schemas)]
+                      (metadata/default-schema)
+                      )]
+        (if-let [schemas (metadata/schemas)]
           (when (or (nil? sname)
                     ((set schemas) sname))
             (analyze Schema sname))
-          (analyze Schema sname))))))
+          (analyze Schema sname))
+
+        ))))

src/lobos/ast.clj

@@ -8,7 +8,7 @@
 
 (ns lobos.ast
   "Abstract SQL syntax tree for the DDL part of the language."
-  (:use clojure.template)
+  (:require [clojure.template :refer :all])
   (:import (java.io Writer)))
 
 ;; -----------------------------------------------------------------------------

src/lobos/backends/h2.clj

@@ -9,9 +9,13 @@
 (ns lobos.backends.h2
   "Compiler implementation for H2."
   (:refer-clojure :exclude [compile defonce])
-  (:require (lobos [schema :as schema]))
-  (:use (clojure [string :only [split]])
-        (lobos analyzer compiler connectivity internal metadata utils))
+  (:require [clojure.string :refer [split]]
+            (lobos [analyzer :refer :all]
+                   [compiler :refer :all]
+                   [internal :refer :all]
+                   [metadata :refer :all]
+                   [schema :as schema]
+                   [utils :refer :all]))
   (:import (lobos.ast AlterRenameAction
                       AutoIncClause
                       CreateSchemaStatement

src/lobos/backends/sqlite.clj

@@ -9,8 +9,12 @@
 (ns lobos.backends.sqlite
   "Compiler implementation for SQLite."
   (:refer-clojure :exclude [compile defonce])
-  (:require (lobos [schema :as schema]))
-  (:use (lobos analyzer compiler connectivity internal metadata utils))
+  (:require (lobos [analyzer :refer :all]
+                   [compiler :refer :all]
+                   [schema :as schema]
+                   [internal :refer :all]
+                   [metadata :refer :all]
+                   [utils :refer :all]))
   (:import (lobos.ast AlterTableStatement
                       AutoIncClause
                       CreateSchemaStatement
@@ -149,9 +153,8 @@
              #(schema/build-drop-statement % :cascade db-spec)
              #(schema/table %)
              :name)
-       (with-connection db-spec
-         (raw-query
-          (format "select name from sqlite_master where type <> 'index';")))))
+       (raw-query
+        (format "select name from sqlite_master where type <> 'index';"))))
 
 (defmethod compile [:sqlite DropStatement]
   [statement]

src/lobos/compiler.clj

@@ -126,7 +126,7 @@
   (let [{:keys [db-spec name qualifiers]} identifier]
     (join* \. (->> (concat qualifiers [name])
                    (filter identity)
-                   (map #(when % (as-str \" % \")))))))
+                   (map #(when % (as-str \" % \" )))))))
 
 (defmethod compile [::standard FunctionExpression]
   [function]