Revert "Merge pull request #3510 from rbrw/pdb-5161-parse-ast-query-fields"

Temporarily revert this work so that we can fix a regression
(PDB-5214) with lower risk.  We plan to restore it right after.

This reverts commit 957f533, reversing
changes made to f89c4c6.

Author: rbrw

src/puppetlabs/puppetdb/jdbc.clj

@@ -13,8 +13,7 @@
   (:import
    (com.zaxxer.hikari HikariDataSource HikariConfig)
    (java.sql Connection SQLException SQLTransientConnectionException)
-   (java.util.concurrent TimeUnit)
-   (org.postgresql.util PGobject)))
+   (java.util.concurrent TimeUnit)))
 
 (def ^:dynamic *db* nil)
 
@@ -393,26 +392,6 @@
   [s]
   (str "\"" (escape-double-quotes s) "\""))
 
-(defn string->text-array-literal
-  "Escape string s for inclusion in a postgres text[] literal,
-  e.g. \"foo\\\"bar\" becomes the \"foo\\\\\\\"bar\" in
-  '{\"foo\\\\\\\"bar\"}'"
-  ;; https://www.postgresql.org/docs/11/arrays.html#ARRAYS-INPUT
-  ;; https://www.postgresql.org/docs/11/sql-syntax-lexical.html#SQL-SYNTAX-CONSTANTS
-  [s]
-  (assert (string? s))
-  (str \" (str/replace s "\\" "\\\\") \"))
-
-(defn strs->db-array
-  [strs]
-  (assert (every? string? strs))
-  ;; https://www.postgresql.org/docs/11/arrays.html#ARRAYS-INPUT
-  (let [quoted (map string->text-array-literal strs)]
-    (doto (PGobject.)
-      (.setType "text[]")
-      (.setValue (str \{ (str/join \, quoted) \})))))
-
-;; Q: move/replace?
 (defn create-json-path-extraction
   "Given a base json field and a path of keys to traverse, construct the proper
   SQL query of the form base->'key'->'key2'..."

src/puppetlabs/puppetdb/query_eng/engine.clj

@@ -244,6 +244,12 @@
   (hcore/raw
    (format "%s = ANY(?)" (first (hfmt/format column)))))
 
+(defn json-contains
+  [field array-in-path]
+  (if array-in-path
+    (hcore/raw (format "%s #> ? = ?" field))
+    (hcore/raw (format "%s @> ?" field))))
+
 (defn jsonb-path-binary-expression
   "Produce a predicate that compares against nested value with op and checks the
   existence of a (presumably) top-level value. The existence check is necessary
@@ -376,3 +382,42 @@
   (log/info (trs "Analyzing small tables"))
   (apply jdbc/do-commands-outside-txn
          (map #(str "analyze " %) small-tables)))
+
+(defn handle-quoted-path-segment
+  [v]
+  (loop [result []
+         [s & splits] v]
+    (let [s-len (count s)]
+      (if (and (str/ends-with? s "\"")
+               (not (= s-len 1))
+               (or (<= s-len 2) (not (= (nth s (- s-len 2)) \\))))
+        [(str/join "." (conj result s)) splits]
+        (recur (conj result s) splits)))))
+
+(defn dotted-query->path
+  [string]
+  (loop [[s & splits :as v] (str/split string #"\.")
+         result []]
+    (if (nil? s)
+      result
+      (let [s-len (count s)]
+        (if (and (str/starts-with? s "\"")
+                 (or (= s-len 1)
+                     (or (not (str/ends-with? s "\""))
+                         (and (str/ends-with? s "\"")
+                              (>= s-len 2)
+                              (= (nth s (- s-len 2)) \\)))))
+          (let [[x xs] (handle-quoted-path-segment v)]
+            (recur xs (conj result x)))
+          (recur splits (conj result s)))))))
+
+(defn expand-array-access-in-path
+  "Given a path like [\"a\" \"b[0]\" \"c\"], expand the [0] to get
+   [\"a\" \"b\" 0 \"c\"]"
+  [path]
+  (mapcat (fn [el]
+            (let [[[_ field index-str]] (re-seq #"^(.*)\[(\d+)\]$" el)]
+              (if index-str
+                [field (Integer/parseInt index-str)]
+                [el])))
+          path))

src/puppetlabs/puppetdb/query_eng/parse.clj

@@ -285,6 +285,24 @@
       (apply assoc m new-kvs)
       m)))
 
+(defn parse-matchfields
+  [s]
+  (str/replace s #"match\((\".*\")\)" "$1"))
+
+(defn parse-indexing
+  [s]
+  (str/replace s #"\[(\d+)\]" ".$1"))
+
+(defn split-indexing
+  [path]
+  (flatten
+    (for [s path]
+      (if (re-find #"\[\d+\]$" s)
+        (-> s
+            (str/split #"(?=\[\d+\]$)")
+            (update 1 #(Integer/parseInt (subs % 1 (dec (count %))))))
+        s))))
+
 (defn regex-quote
   [s]
   (when (and (string? s) (re-find #"\\E" s))

src/puppetlabs/puppetdb/scf/storage_utils.clj

@@ -17,6 +17,14 @@
                       (interpose "\\E\\\\E\\Q"))
                  ["\\E"])))
 
+(defn maybe-strip-escaped-quotes
+  [s]
+  (if (and (> (count s) 1)
+           (string/starts-with? s "\"")
+           (string/ends-with? s "\""))
+    (subs s 1 (dec (count s)))
+    s))
+
 (defn quoted
   [s]
   (str "'" s "'"))

src/puppetlabs/puppetdb/utils.clj

@@ -1,9 +1,9 @@
 (ns puppetlabs.puppetdb.pql.parser-test
-  (:require
-   [clojure.string :as str]
-   [clojure.test :refer :all]
-   [instaparse.core :as insta]
-   [puppetlabs.puppetdb.pql :refer [parse]]))
+  (:require [clojure.test :refer :all]
+            [clojure.string :as str]
+            [instaparse.core :as insta]
+            [puppetlabs.puppetdb.scf.storage-utils :as sutils]
+            [puppetlabs.puppetdb.pql :refer [parse]]))
 
 ;; These tests are ordered the same as in the EBNF file, so one can
 ;; develop the expressions and tests side-by-side.
@@ -563,18 +563,18 @@
       ""))
 
   (testing "field"
-    (doseq [[field expected]
-            [["certname" [:field "certname"]]
-             ["value" [:field "value"]]
-             ["field_underscore" [:field "field_underscore"]]
-             ["facts.operatingsystem.κόσμε" [:field "facts" "operatingsystem" "κόσμε"]]
-             ["facts.\"quoted field\".foo" [:field "facts" "\"quoted field\"" "foo"]]
-             ["facts.\"field.with.dot\".foo" [:field "facts" "\"field.with.dot\"" "foo"]]
-             ["facts.\"field-with-dash\".foo" [:field "facts" "\"field-with-dash\"" "foo"]]
-             ["trusted.authenticated" [:field "trusted" "authenticated"]]
-             ["parameters.😁" [:field "parameters" "😁"]]
-             ["latest_report?" [:field "latest_report?"]]]]
-      (is (= expected (parse field :start :field))))
+    (are [in] (= (parse in :start :field)
+                 (vec (concat [:field] (sutils/dotted-query->path in))))
+         "certname"
+         "value"
+         "field_underscore"
+         "facts.operatingsystem.κόσμε"
+         "facts.\"quoted field\".foo"
+         "facts.\"field.with.dot\".foo"
+         "facts.\"field-with-dash\".foo"
+         "trusted.authenticated"
+         "parameters.😁"
+         "latest_report?")
 
     (are [in] (insta/failure? (insta/parse parse in :start :field))
       "'asdf'"