Feature/inline multivariable filters

src/fluree/db/async_db.cljc

@@ -232,10 +232,10 @@
       root-db))
 
   optimize/Optimizable
-  (-reorder [_ parsed-query]
+  (-reorder [_ where-clause]
     (go-try
       (let [db (<? db-chan)]
-        (<? (optimize/-reorder db parsed-query)))))
+        (<? (optimize/-reorder db where-clause)))))
 
   (-explain [_ parsed-query]
     (go-try

src/fluree/db/dataset.cljc

@@ -137,10 +137,11 @@
                  nil)))))
 
   optimize/Optimizable
-  (-reorder [_ds parsed-query]
-    ;; DataSets (federated queries) are not optimized
-    ;; Return query unchanged wrapped in channel
-    (async/go parsed-query))
+  (-reorder [_ds where-clause]
+    ;; DataSets (federated queries) are not optimized.
+    ;; Return the clause unchanged wrapped in a channel to maintain the
+    ;; optimizer contract without performing any work.
+    (async/go where-clause))
 
   (-explain [_ds parsed-query]
     ;; DataSets (federated queries) cannot be explained

src/fluree/db/flake/flake_db.cljc

@@ -16,7 +16,7 @@
             [fluree.db.flake.index.novelty :as novelty]
             [fluree.db.flake.index.storage :as index-storage]
             [fluree.db.flake.match :as match]
-            [fluree.db.flake.optimize :refer  [explain-query optimize-query]]
+            [fluree.db.flake.optimize :refer  [explain-query optimize-where]]
             [fluree.db.flake.reasoner :as flake.reasoner]
             [fluree.db.flake.transact :as flake.transact]
             [fluree.db.indexer :as indexer]
@@ -506,8 +506,9 @@
     (reasoner-util/reasoned-facts db))
 
   optimize/Optimizable
-  (-reorder [db parsed-query]
-    (async/go (optimize-query db parsed-query)))
+  (-reorder [db where-clause]
+    (async/go
+      (optimize-where db where-clause)))
 
   (-explain [db parsed-query]
     (async/go (explain-query db parsed-query))))

src/fluree/db/flake/optimize.cljc

@@ -484,16 +484,16 @@
     {:type    :boundary
      :pattern (pattern->user-format (:pattern segment) compact-fn)}))
 
-(defn optimize-query
-  "Optimize a parsed query using statistics if available.
-   Returns the optimized query with patterns reordered for optimal execution.
-   Uses fast path - extracts optimized patterns without formatting."
-  [db parsed-query]
+(defn optimize-where
+  "Optimize a parsed where clause using statistics if available.
+   Returns the optimized clause in execution order, or the original clause when
+   statistics are unavailable."
+  [db where-clause]
   (let [stats (:stats db)]
-    (if (and stats (not-empty stats) (:where parsed-query))
-      (let [{:keys [optimized]} (optimize-patterns-with-metadata db (:where parsed-query))]
-        (assoc parsed-query :where optimized))
-      parsed-query)))
+    (if (and stats (not-empty stats) (seq where-clause))
+      (let [{:keys [optimized]} (optimize-patterns-with-metadata db where-clause)]
+        optimized)
+      where-clause)))
 
 (defn explain-query
   "Generate an execution plan for the query showing optimization details.

src/fluree/db/query/exec/where.cljc

@@ -615,8 +615,8 @@
 
 (defn filter-exception
   "Reformats raw filter exception to try to provide more useful feedback."
-  [e f]
-  (let [fn-str (->> f meta :forms (str/join " "))
+  [e filter-desc]
+  (let [fn-str (str/join " " (:forms filter-desc))
         ex-msg (or (ex-message e)
                    ;; note: NullPointerException is common but has no ex-message, create one
                    (let [ex-type (str (type e))] ;; attempt to make JS compatible
@@ -655,12 +655,13 @@
 (defmethod match-pattern :filter
   [_ds _tracker solution pattern error-ch]
   (go
-    (let [f (pattern-data pattern)]
+    (let [desc (pattern-data pattern)
+          f    (:fn desc)]
       (try*
         (let [result (f solution)]
           (when result
             solution))
-        (catch* e (>! error-ch (filter-exception e f)))))))
+        (catch* e (>! error-ch (filter-exception e desc)))))))
 
 (defn with-constraint
   "Return a channel of all solutions from the data set `ds` that extend from the

src/fluree/db/query/fql/parse.cljc

@@ -344,15 +344,15 @@
                        [var binding]))))
         binds))
 
-(defn higher-order-pattern?
-  "A non-node where pattern."
+(defn vector-pattern?
+  "True when the where clause pattern is expressed as a vector form rather than a node map."
   [pattern]
   (and (sequential? pattern) (keyword? (first pattern))))
 
 (defn parse-where-clause
   [clause var-config context]
-  ;; a single higher-order where pattern is already sequential, so we need to check if it needs wrapping
-  (let [clause* (if (higher-order-pattern? clause)
+  ;; a single vector-form where pattern is already sequential, so we need to check if it needs wrapping
+  (let [clause* (if (vector-pattern? clause)
                   [clause]
                   (util/sequential clause))]
     (->> clause*
@@ -577,10 +577,16 @@
 
 (defmethod parse-pattern :filter
   [[_ & codes] _var-config context]
-  (let [parsed-codes (map parse-code codes)
-        vars         (apply set/union (map variables parsed-codes))
-        f            (compile-filter-fn context parsed-codes)]
-    [(where/->pattern :filter (with-meta f {:forms parsed-codes, :vars vars}))]))
+  (let [parsed-codes (mapv parse-code codes)
+        vars         (->> parsed-codes
+                          (map variables)
+                          (reduce set/union #{})
+                          not-empty)
+        f            (compile-filter-fn context parsed-codes)
+        info         {:fn    f
+                      :forms parsed-codes
+                      :vars  vars}]
+    [(where/->pattern :filter info)]))
 
 (defmethod parse-pattern :union
   [[_ & unions] var-config context]
@@ -778,22 +784,16 @@
       (assoc q select-key select))
     q))
 
-(defn ensure-vector
-  [x]
-  (if (vector? x)
-    x
-    [x]))
-
 (defn parse-grouping
   [q]
   (some->> (:group-by q)
-           ensure-vector
+           util/ensure-vector
            (mapv parse-var-name)))
 
 (defn parse-ordering
   [q]
   (some->> (:order-by q)
-           ensure-vector
+           util/ensure-vector
            (mapv (fn [ord]
                    (if-let [v (parse-var-name ord)]
                      [v :asc]