            retry-policy
            reconnection-policy
            load-balancing-policy
-           force-prepared-queries
            ssl
            ssl-options
            kerberos
            protocol-version
            compression]
     :or {protocol-version 2}}]
-  (when force-prepared-queries
-    (alter-var-root (var hayt/*prepared-statement*)
-                    (constantly true)))
   (when consistency-level
     (alter-var-root (var cp/*consistency-level*)
                     (constantly (cp/resolve-consistency-level consistency-level))))

           ^ResultSetFuture fut (.executeAsync session statement)]
       (future (conv/to-clj (.getUninterruptibly fut))))))

(defn execute
  "Executes a pre-built query.

   Options
     * prepared - whether the query should or should not be executed as prepared, always passed
       explicitly, because `execute` is considered to be a low-level function."
  ([^Session session query]
     (execute session query {}))
  ([^Session session query {:keys [prepared fetch-size]}]
     (let [^Statement statement (statement-for session query prepared)
           _                    (when fetch-size
                                  (.setFetchSize statement fetch-size))
           ^ResultSetFuture fut (.executeAsync session statement)
           res                  (.getUninterruptibly fut)]
       (conv/to-clj res))))

(defn ^String export-schema
  "Exports the schema as a string"

    (.setConsistencyLevel statement (cp/resolve-consistency-level cp/*consistency-level*)))
  statement)

(defn ^:private build-statement-
  "Builds a Prepare or Simple statement out of given params.

   Arities:
