   (assert (not cc/*prepared-statement*) "get-one query can't be executed as a prepared query")
   (first
    (cc/execute session
-               (compile-query- q/select-query query-params))))
-
-(defn perform-count
-  "Helper function to perform count on a table with given query. Count queries are slow in Cassandra,
-   in order to get a rough idea of how many items you have in certain table, use `nodetool cfstats`,
-   for more complex cases, you can wither do a full table scan or perform a count with this function,
-   please note that it does not have any performance guarantees and is potentially expensive.
-
-   Doesn't work as a prepared query."
-  [^Session session table & query-params]
-  (assert (not cc/*prepared-statement*) "Count query can't be executed as a prepared query")
-  (:count
-   (first
-    (select session table
-            (cons
-             (q/columns (q/count*))
-             query-params)))))
+               (apply new-query-api/select query-params))))
+
+;; (defn perform-count
+;;   "Helper function to perform count on a table with given query. Count queries are slow in Cassandra,
+;;    in order to get a rough idea of how many items you have in certain table, use `nodetool cfstats`,
+;;    for more complex cases, you can wither do a full table scan or perform a count with this function,
+;;    please note that it does not have any performance guarantees and is potentially expensive.
+
+;;    Doesn't work as a prepared query."
+;;   [^Session session table & query-params]
+;;   (assert (not cc/*prepared-statement*) "Count query can't be executed as a prepared query")
+;;   (:count
+;;    (first
+;;     (select session table
+;;             (cons
+;;              (q/columns (q/count*))
+;;              query-params)))))
 
 ;;
 ;; Higher-level helper functions for schema
 ;;
 
-(defn describe-keyspace
-  "Returns a keyspace description, taken from `system.schema_keyspaces`."
-  [^Session session ks]
-  (assert (not cc/*prepared-statement*) "Describe Keyspace query can't be executed as a prepared query")
-  (first
-   (select session :system.schema_keyspaces
-           (q/where {:keyspace_name (name ks)}))))
-
-(defn describe-table
-  "Returns a table description, taken from `system.schema_columnfamilies`."
-  [^Session session ks table]
-  (assert (not cc/*prepared-statement*) "Describe Table query can't be executed as a prepared query")
-  (first
-   (select session :system.schema_columnfamilies
-           (q/where {:keyspace_name (name ks)
-                     :columnfamily_name (name table)}))))
-
-(defn describe-columns
-  "Returns table columns description, taken from `system.schema_columns`."
-  [^Session session ks table]
-  (assert (not cc/*prepared-statement*) "Describe Columns query can't be executed as a prepared query")
-  (select session :system.schema_columns
-          (q/where {:keyspace_name (name ks)
-                    :columnfamily_name (name table)})))
+;; (defn describe-keyspace
+;;   "Returns a keyspace description, taken from `system.schema_keyspaces`."
+;;   [^Session session ks]
+;;   (assert (not cc/*prepared-statement*) "Describe Keyspace query can't be executed as a prepared query")
+;;   (first
+;;    (select session :system.schema_keyspaces
+;;            (q/where {:keyspace_name (name ks)}))))
+
+;; (defn describe-table
+;;   "Returns a table description, taken from `system.schema_columnfamilies`."
+;;   [^Session session ks table]
+;;   (assert (not cc/*prepared-statement*) "Describe Table query can't be executed as a prepared query")
+;;   (first
+;;    (select session :system.schema_columnfamilies
+;;            (q/where {:keyspace_name (name ks)
+;;                      :columnfamily_name (name table)}))))
+
+;; (defn describe-columns
+;;   "Returns table columns description, taken from `system.schema_columns`."
+;;   [^Session session ks table]
+;;   (assert (not cc/*prepared-statement*) "Describe Columns query can't be executed as a prepared query")
+;;   (select session :system.schema_columns
+;;           (q/where {:keyspace_name (name ks)
+;;                     :columnfamily_name (name table)})))
 
 ;;
 ;; Higher-level collection manipulation
 ;;
 
-(defn- load-chunk
-  "Returns next chunk for the lazy table iteration"
-  [^Session session table partition-key chunk-size last-pk]
-  (if (nil? (first last-pk))
-    (select session table
-            (q/limit chunk-size))
-    (select session table
-            (q/where [[> (apply q/token partition-key) (apply q/token last-pk)]])
-            (q/limit chunk-size))))
-
-(defn iterate-table
-  "Lazily iterates through a table, returning chunks of chunk-size."
-  ([^Session session table partition-key chunk-size]
-     (iterate-table session table (if (sequential? partition-key)
-                                    partition-key
-                                    [partition-key])
-                    chunk-size []))
-  ([^Session session table partition-key chunk-size c]
-     (lazy-cat c
-               (let [last-pk    (map #(get (last c) %) partition-key)
-                     next-chunk (load-chunk session table partition-key chunk-size last-pk)]
-                 (if (empty? next-chunk)
-                   []
-                   (iterate-table session table partition-key chunk-size next-chunk))))))
-
-(defn copy-table
-  "Copies data from one table to another, transforming rows
-   using provided function (`transform-fn`)"
-  ([^Session session from-table to-table partition-key]
-     (copy-table session from-table to-table partition-key 16384))
-  ([^Session session from-table to-table partition-key chunk-size]
-     (copy-table session from-table to-table partition-key identity chunk-size))
-  ([^Session session from-table to-table partition-key transform-fn chunk-size]
-     (doseq [row (iterate-table session from-table partition-key chunk-size)]
-       (insert session to-table (transform-fn row)))))
+;; (defn- load-chunk
+;;   "Returns next chunk for the lazy table iteration"
+;;   [^Session session table partition-key chunk-size last-pk]
+;;   (if (nil? (first last-pk))
+;;     (select session table
+;;             (q/limit chunk-size))
+;;     (select session table
+;;             (q/where [[> (apply q/token partition-key) (apply q/token last-pk)]])
+;;             (q/limit chunk-size))))
+
+;; (defn iterate-table
+;;   "Lazily iterates through a table, returning chunks of chunk-size."
+;;   ([^Session session table partition-key chunk-size]
+;;      (iterate-table session table (if (sequential? partition-key)
+;;                                     partition-key
+;;                                     [partition-key])
+;;                     chunk-size []))
+;;   ([^Session session table partition-key chunk-size c]
+;;      (lazy-cat c
+;;                (let [last-pk    (map #(get (last c) %) partition-key)
+;;                      next-chunk (load-chunk session table partition-key chunk-size last-pk)]
+;;                  (if (empty? next-chunk)
+;;                    []
+;;                    (iterate-table session table partition-key chunk-size next-chunk))))))
+
+;; (defn copy-table
+;;   "Copies data from one table to another, transforming rows
+;;    using provided function (`transform-fn`)"
+;;   ([^Session session from-table to-table partition-key]
+;;      (copy-table session from-table to-table partition-key 16384))
+;;   ([^Session session from-table to-table partition-key chunk-size]
+;;      (copy-table session from-table to-table partition-key identity chunk-size))
+;;   ([^Session session from-table to-table partition-key transform-fn chunk-size]
+;;      (doseq [row (iterate-table session from-table partition-key chunk-size)]
+;;        (insert session to-table (transform-fn row)))))

   for this function should always be table name."
  [^Session session table & query-params]
  (cc/execute session
              (compile-query- q/delete-query (cons table query-params))))

(defn delete-async
  "Same as delete but returns a future"

   Other columns values are specified through assignment within the `set` clause."
  [^Session session & query-params]
  (cc/execute session
              (apply new-query-api/update query-params)))

(defn update-async
  "Same as update but returns a future"
