metabase.query-processor.util

(ns metabase.query-processor.util
  (:require
   [buddy.core.codecs :as codecs]
   [buddy.core.hash :as buddy-hash]
   [clojure.string :as str]
   [clojure.walk :as walk]
   [medley.core :as m]
   [metabase.driver :as driver]
   [metabase.legacy-mbql.normalize :as mbql.normalize]
   [metabase.lib.convert :as lib.convert]
   [metabase.lib.schema.expression :as lib.schema.expression]
   [metabase.lib.schema.util :as lib.schema.util]
   [metabase.query-processor.schema :as qp.schema]
   [metabase.util :as u]
   [metabase.util.json :as json]
   [metabase.util.malli :as mu]))

(set! *warn-on-reflection* true)

(defn query-without-aggregations-or-limits?
  [{{aggregations :aggregation, :keys [limit page]} :query}]
  (and (not limit)
       (not page)
       (empty? aggregations)))

(defn default-query->remark
  [{{:keys [executed-by query-hash], :as _info} :info, query-type :type}]
  (str "Metabase" (when executed-by
                    (assert (bytes? query-hash) "If info includes executed-by it should also include query-hash")
                    (format ":: userID: %s queryType: %s queryHash: %s"
                            executed-by
                            (case (keyword query-type)
                              :query  "MBQL"
                              :native "native")
                            (codecs/bytes->hex query-hash)))))

(defmulti query->remark
  {:arglists '(^String [driver query])}
  driver/dispatch-on-initialized-driver
  :hierarchy #'driver/hierarchy)

(defmethod query->remark :default
  [_ query]
  (default-query->remark query))

(mu/defn ^:deprecated normalize-token :- :keyword
  "Convert a string or keyword in various cases (`lisp-case`, `snake_case`, or `SCREAMING_SNAKE_CASE`) to a lisp-cased
  keyword."
  [token :- [:or :keyword :string]]
  (-> (name token)
      u/lower-case-en
      (str/replace #"_" "-")
      keyword))

(defn- walk-query-sort-maps
  [x]
  (walk/postwalk
   (fn [x]
     (if (and (map? x)
              (not (sorted? x)))
       (into (sorted-map) x)
       x))
   x))

(mu/defn- sort-parameter-values
  [params :- [:or :nil [:sequential :any]]]
  (map #(if (sequential? (:value %)) (update % :value sort) %) params))

(mu/defn- select-keys-for-hashing
  [query :- [:maybe :map]]
  (let [{:keys [constraints parameters], :as query} (select-keys query [:database :lib/type :stages :parameters :constraints])]
    (cond-> query
      (empty? constraints) (dissoc :constraints)
      true                 (update :parameters sort-parameter-values)
      (empty? parameters)  (dissoc :parameters)
      true                 lib.schema.util/remove-randomized-idents
      true                 walk-query-sort-maps)))

(mu/defn query-hash :- bytes?
  "Return a 256-bit SHA3 hash of `query` as a key for the cache. (This is returned as a byte array.)"
  ^bytes [query :- [:maybe :map]]
  ;; convert to pMBQL first if this is a legacy query.
  (let [query (try
                ;; Expression type check supression is necessary because coerced fields in `query` may not have
                ;; `:effective-type` populated. That's the case during call to this function in
                ;; `process-userland-query-middleware` that occurs before normalization.
                (binding [lib.schema.expression/*suppress-expression-type-check?* true]
                  (cond-> query
                    (#{"query" "native"} (:type query)) (#(lib.convert/->pMBQL (mbql.normalize/normalize %)))
                    (#{:query :native} (:type query))   lib.convert/->pMBQL))
                (catch Throwable e
                  (throw (ex-info "Error hashing query. Is this a valid query?"
                                  {:query query}
                                  e))))]
    (buddy-hash/sha3-256 (json/encode (select-keys-for-hashing query)))))

(defn query->source-card-id
  ^Integer [outer-query]
  (let [source-table (get-in outer-query [:query :source-table])]
    (when (string? source-table)
      (when-let [[_ card-id-str] (re-matches #"^card__(\d+$)" source-table)]
        (Integer/parseInt card-id-str)))))

(defn field-ref->key
  [[tyype identifier]]
  [tyype identifier])

(def ^:private field-options-for-identification
   ;; base-type is required for field that use name instead of id
  #{:source-field :join-alias :base-type})

(defn- field-normalizer
  [field]
  (let [[type id-or-name options] (mbql.normalize/normalize-tokens field)]
    [type id-or-name (select-keys options field-options-for-identification)]))

(defn field->field-info
  [field result-metadata]
  (let [[_ttype id-or-name options :as field] (field-normalizer field)]
    (or
      ;; try match field_ref first
     (first (filter (fn [field-info]
                      (= field
                         (-> field-info
                             :field_ref
                             field-normalizer)))
                    result-metadata))
      ;; if not match name and base type for aggregation or field with string id
     (first (filter (fn [field-info]
                      (and (= (:name field-info)
                              id-or-name)
                           (= (:base-type options)
                              (:base_type field-info))))
                    result-metadata)))))

(def preserved-keys
  ;; TODO: ideally we don't preserve :id but some notion of :user-entered-id or :identified-id
  [:id :description :display_name :semantic_type
   :fk_target_field_id :settings :visibility_type])

(defn combine-metadata
  [fresh pre-existing]
  (let [by-name (m/index-by :name pre-existing)]
    (for [{:keys [source] :as col} fresh]
      (if-let [existing (and (not= :aggregation source)
                             (get by-name (:name col)))]
        (merge col (select-keys existing preserved-keys))
        col))))

(def ^:dynamic *execute-async?*
  true)

(defn do-with-execute-async
  [thunk]
  (if *execute-async?*
    (.submit clojure.lang.Agent/pooledExecutor ^Runnable thunk)
    (thunk)))

(defmacro with-execute-async
  [thunk]
  `(do-with-execute-async ~thunk))

(mu/defn userland-query? :- :boolean
  "Returns true if the query is an userland query, else false."
  [query :- ::qp.schema/qp]
  (boolean (get-in query [:middleware :userland-query?])))

(mu/defn internal-query? :- :boolean
  "Returns `true` if query is an internal query."
  [{query-type :type} :- ::qp.schema/qp]
  (= :internal (keyword query-type)))