From 7256f7afba5dcf37782b48f58203919879be330e Mon Sep 17 00:00:00 2001
From: Michael Blume <blume.mike@gmail.com>
Date: Fri, 25 Aug 2017 09:11:25 -0700
Subject: [PATCH] Revert "Merge pull request #169"

Revert the reversion, keep the behavior from 0.9.0, vectors will be
primarily used for function calls.
---
 src/honeysql/format.cljc       | 39 ++++++++++++++++++++++------------
 test/honeysql/format_test.cljc | 10 ++-------
 2 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/src/honeysql/format.cljc b/src/honeysql/format.cljc
index 7370469..d2de364 100644
--- a/src/honeysql/format.cljc
+++ b/src/honeysql/format.cljc
@@ -37,6 +37,8 @@
 
 (def ^:dynamic *fn-context?* false)
 
+(def ^:dynamic *value-context?* false)
+
 (def ^:dynamic *subquery?* false)
 
 (def ^:dynamic *allow-dashed-names?* false)
@@ -94,6 +96,10 @@
 (defprotocol ToSql
   (to-sql [x]))
 
+(defn to-sql-value [x]
+  (binding [*value-context?* true]
+    (to-sql x)))
+
 (defmulti fn-handler (fn [op & args] op))
 
 (defn expand-binary-ops [op & args]
@@ -124,40 +130,40 @@
   (if (seq more)
     (apply expand-binary-ops "=" a b more)
     (cond
-     (nil? a) (str (to-sql b) " IS NULL")
-     (nil? b) (str (to-sql a) " IS NULL")
-     :else (str (to-sql a) " = " (to-sql b)))))
+     (nil? a) (str (to-sql-value b) " IS NULL")
+     (nil? b) (str (to-sql-value a) " IS NULL")
+     :else (str (to-sql-value a) " = " (to-sql-value b)))))
 
 (defmethod fn-handler "<>" [_ a b & more]
   (if (seq more)
     (apply expand-binary-ops "<>" a b more)
     (cond
-     (nil? a) (str (to-sql b) " IS NOT NULL")
-     (nil? b) (str (to-sql a) " IS NOT NULL")
-     :else (str (to-sql a) " <> " (to-sql b)))))
+     (nil? a) (str (to-sql-value b) " IS NOT NULL")
+     (nil? b) (str (to-sql-value a) " IS NOT NULL")
+     :else (str (to-sql-value a) " <> " (to-sql-value b)))))
 
 (defmethod fn-handler "<" [_ a b & more]
   (if (seq more)
     (apply expand-binary-ops "<" a b more)
-    (str (to-sql a) " < " (to-sql b))))
+    (str (to-sql-value a) " < " (to-sql-value b))))
 
 (defmethod fn-handler "<=" [_ a b & more]
   (if (seq more)
     (apply expand-binary-ops "<=" a b more)
-    (str (to-sql a) " <= " (to-sql b))))
+    (str (to-sql-value a) " <= " (to-sql-value b))))
 
 (defmethod fn-handler ">" [_ a b & more]
   (if (seq more)
     (apply expand-binary-ops ">" a b more)
-    (str (to-sql a) " > " (to-sql b))))
+    (str (to-sql-value a) " > " (to-sql-value b))))
 
 (defmethod fn-handler ">=" [_ a b & more]
   (if (seq more)
     (apply expand-binary-ops ">=" a b more)
-    (str (to-sql a) " >= " (to-sql b))))
+    (str (to-sql-value a) " >= " (to-sql-value b))))
 
 (defmethod fn-handler "between" [_ field lower upper]
-  (str (to-sql field) " BETWEEN " (to-sql lower) " AND " (to-sql upper)))
+  (str (to-sql-value field) " BETWEEN " (to-sql-value lower) " AND " (to-sql-value upper)))
 
 ;; Handles MySql's MATCH (field) AGAINST (pattern). The third argument
 ;; can be a set containing one or more of :boolean, :natural, or :expand.
@@ -166,7 +172,7 @@
        (comma-join
         (map to-sql (if (coll? fields) fields [fields])))
        ") AGAINST ("
-       (to-sql pattern)
+       (to-sql-value pattern)
        (when (seq opts)
          (str " " (space-join (for [opt opts]
                                 (case opt
@@ -313,10 +319,17 @@
       (paren-wrap sql-str)
       sql-str)))
 
+(declare format-predicate*)
+
 (defn seq->sql [x]
-  (if *fn-context?*
+  (cond
+    *value-context?*
+    ;; sequences are operators/functions
+    (format-predicate* x)
+    *fn-context?*
     ;; list argument in fn call
     (paren-wrap (comma-join (map to-sql x)))
+    :else
     ;; alias
     (str (to-sql (first x))
          ; Omit AS in FROM, JOIN, etc. - Oracle doesn't allow it
diff --git a/test/honeysql/format_test.cljc b/test/honeysql/format_test.cljc
index 338671e..acc9cb3 100644
--- a/test/honeysql/format_test.cljc
+++ b/test/honeysql/format_test.cljc
@@ -116,11 +116,11 @@
            ["SELECT amount, id, created_on FROM transactions UNION SELECT amount, id, created_on FROM (SELECT amount, id, created_on FROM other_transactions ORDER BY amount DESC LIMIT ?) ORDER BY amount ASC" 5]))))
 
 (deftest compare-expressions-test
-  (testing "sql/call should produce appropriate function calls"
+  (testing "Sequences should be fns when in value/comparison spots"
     (is (= ["SELECT foo FROM bar WHERE (col1 mod ?) = (col2 + ?)" 4 4]
            (format {:select [:foo]
                     :from [:bar]
-                    :where (sql/call := (sql/call :mod :col1 4) (sql/call :+ :col2 4))})))))
+                    :where [:= [:mod :col1 4] [:+ :col2 4]]})))))
 
 (deftest union-with-cte
   (is (= (format {:union [{:select [:foo] :from [:bar1]}
@@ -136,9 +136,3 @@
                   :with [[[:bar {:columns [:spam :eggs]}]
                           {:values [[1 2] [3 4] [5 6]]}]]})
          ["WITH bar (spam, eggs) AS (VALUES (?, ?), (?, ?), (?, ?)) SELECT foo FROM bar1 UNION ALL SELECT foo FROM bar2" 1 2 3 4 5 6])))
-
-(deftest format-tuples
-  (is (= ["SELECT id FROM table WHERE (a, b) = (?, ?)" 1 2]
-         (format {:select [:id]
-                  :from   [:table]
-                  :where  [:= [:a :b] [1 2]]}))))