2

我想在保持全局条（col-k）中的顺序的同时对堆栈元素（group-by-k）进行排序。

$order 函数不允许一次对多列进行排序。因此，该函数两次，但是，最后一个排序不会保留前一个排序。所以我可以对全局条进行排序，也可以对条的堆叠元素进行排序，但不能同时进行！

我怎样才能做到这一点？我怀疑我们需要sorted-map在内部工作，$fn但不确定如何实现...

这是我为尝试多重排序而编写的函数。

(require
   (incanter '[core :as core]
             '[charts :as charts])

(defn sorted-barchart [data col-k & {:keys [group-by-k 
                                            order-k 
                                            order-sign 
                                            order-group-k 
                                            order-group-sign 
                                            title 
                                            x-label 
                                            y-label 
                                            legend]}]
  (core/with-data
    (let [d (core/to-dataset data)
          d1 (core/$where {group-by-k {:$fn #(not (empty? %))}} d)
          d2 (core/$where {col-k {:$fn #(not (empty? %))}} d1)
          d3 (core/$rollup :count :counts (if group-by-k [col-k group-by-k] [col-k]) d2)
          d4 (core/$order (or order-k col-k) (or order-sign nil) d3)
          d5 (core/$order (or order-group-k group-by-k)
                          (or order-group-sign nil) d4)]
      d5) 
    (let [chart (charts/stacked-bar-chart col-k :counts
                                           :group-by group-by-k 
                                           :vertical false
                                           :x-label (or x-label " ")
                                           :y-label (or y-label " ")
                                           :title (or title " ")
                                           :legend (or legend true)
                                           :series-label "Total")]
      chart)))

编辑：这实际上在按 col-k 和 group-by-k 排序时有效。但是，当您想首先按计数排序时，当您还希望对堆栈元素进行排序时，在按计数排序时保留 col-k 顺序会变得更加棘手。

4

1 回答 1

1

我们可以只索引主键上的计数（col-k），然后按索引和堆叠键排序（group-by-k）。

因此，在sorted-barchart函数中，我们可以将 d4 和 d5 替换为以下内容：

(if
  (and group-by-k order-k (not= order-k col-k))
  (let [d-count (core/$ col-k 
                        (core/$order :c 
                                     :desc 
                                     (core/$rollup :count :c [col-k] d2)))
        d-index (core/dataset [:index col-k] 
                              (map-indexed vector d-count))
        d-join (core/$join [col-k col-k] d-index d3)]
    (->> d-join
         (core/$order (or order-group-k group-by-k)
                      (or order-group-sign :asc))
         (core/$order :index :asc)))
  (let [d-new (if group-by-k 
                (core/$order (or order-group-k group-by-k)
                             (or order-group-sign :asc) d3)
                d3)]
    (core/$order (or order-k col-k) (or order-sign :desc) d-new)))
于 2016-12-06T16:00:25.927 回答