2

tl；博士如何将 IReduceInit 转换为转换值的惰性序列

我有一个数据库查询，它产生了一个相当大的数据集，用于在客户端上进行实时旋转（百万或两行，25 个属性 - 对于现代笔记本电脑来说没问题）。

我的（简化的）堆栈是调用 clojure.jdbc 来获取（我认为是惰性的）结果行序列。我可以通过 ring-json 中间件将其作为主体传递出去，从而将其序列化。ring-json 在堆上构建响应字符串存在问题，但是从 0.5.0 开始可以选择将响应流式传输出去。

我通过分析几个失败案例发现，实际上 clojure.jdbc 在将其返回之前将整个结果集实现在内存中。没问题！reducible-query我决定转向新的 next.jdbc，而不是在那个库中工作。

next.jdbc 中的关键操作是plan返回一个 IReduceInit，我可以使用它来运行查询并获取结果集...

(into [] (map :cc_id) (jdbc/plan ds ["select cc_id from organisation where cc_id = '675192'"]))
["675192"]

然而，这实现了整个结果集，并且在上述情况下会给我所有的 id 预先和内存。对一个人来说不是问题，但我通常有很多。

如果我给出一个起始值，我可以减少 IReduceInit 计划，所以我可以在减少函数中进行输出......（谢谢@amalloy）

(reduce #(println (:cc_id %2)) [] (jdbc/plan ds ["select cc_id from organisation where cc_id = '675192'"]))
675192
nil

...但理想情况下，我想在对它们应用转换函数后将此 IReduceInit 转换为值的惰性序列，因此我可以将它们与 ring-json 和 cheshire 一起使用。我没有看到任何明显的方法。

4

4 回答 4

2

reduce与 IReduceInit 一起工作正常。IReduceInit 需要一个初始值，这是您在调用 .reduce 时指定的，但在使用 reduce 函数时不需要；这解释了为什么你看到一个工作但没有另一个。

但是，这不会让你得到一个懒惰的序列。合同的一部分reduce是它急切地消耗整个输入（我们将忽略reduced不会改变任何有意义的东西）。您的问题是动态范围更普遍问题的一个具体案例：JDBC 生成的序列仅在某些上下文中“有效”，您需要在此上下文中进行所有处理，因此不能偷懒。相反，你通常把你的程序翻过来：不要将返回值用作序列，而是向查询引擎传递一个函数并说，“请用你的结果调用这个函数”。然后，引擎在调用该函数时确保数据有效，并在函数返回后清理数据。我不知道 jdbc.next，db-query-with-resultset为了这。您将向它传递一些函数，该函数可以将字节添加到待处理的 HTTP 响应中，并且它会多次调用该函数。

这有点含糊，因为我不知道您正在使用什么 HTTP 处理程序，或者它用于非延迟处理流式响应的设施是什么，但如果您想处理，这是您必须遵循的一般想法动态范围的资源：懒惰不是一种选择。

于 2019-09-23T20:26:25.383 回答
1

令人沮丧。

为什么你不能用 JDBC 做到这一点呢？没有任何 Clojure 层？

(let [resultset (.executeQuery connection "select ...")]
  (loop 
   (when (.next resultset)
     (let [row [(.getString resultset 1)
                (.getString resultset 2)
                ...]])
     (json/send row)
     (recur)))
  (json/end))

当然，使用 ResultSetMetaData 您可以将行的生成自动化到一个可以处理任何返回的函数中。

于 2019-09-24T06:58:20.777 回答
1

IReduceInit 使 JDBC 资源能够在 reduce 函数退出时结束。这比 LazySeq 方法更可预测，后者可能永远不会释放 JDBC 资源。

您使用 BlockingQueue 和未来任务来填充该队列，如下所示

 (defn lazywalk-reducible
  "walks the reducible in chunks of size n,
  returns an iterable that permits access"
  [n reducible]
  (reify java.lang.Iterable
    (iterator [_]
      (let [bq (java.util.concurrent.ArrayBlockingQueue. n)
            finished? (volatile! false)
            traverser (future (reduce (fn [_ v] (.put bq v)) nil reducible)
                              (vreset! finished? true))]
        (reify java.util.Iterator
          (hasNext [_] (or (false? @finished?) (false? (.isEmpty bq))))
          (next [_] (.take bq)))))))

如果生成了迭代器但没有遵循它的结论，这当然会造成泄漏。

我没有彻底测试过，它也可能有其他问题；但这种方法应该有效。

clojure.lang.ISeq如果 Java Iterable 对您的用例不够好，您也可以使其具体化；但随后你开始进入 HeadRetention 问题；以及如何处理一个Object first()非常可行的电话，但我不想多想

于 2020-08-26T14:52:25.460 回答
1

我的惰性序列是一个坏主意的原因有很多——即使我保证不抱头，结果流期间的异常问题无疑会使 ResultSet 闲置——序列化将发生在调用堆栈之外可以清理。

懒惰的需求是由不想在内存中实现整个结果的愿望驱动的，需要 seq 或其他 coll？以便中间件将其序列化...

因此，直接使 IReduceInit JSONable，然后绕过中间件。如果在序列化过程中出现异常，控件将通过 next.jdbc 中的 IReduceInit，然后可以进行有意义的清理。

;; reuse this body generator from my patch to ring.middleware.json directly, as the coll? check will fail
(defrecord JsonStreamingResponseBody [body options]
  ring-protocols/StreamableResponseBody
  (write-body-to-stream [_ _ output-stream]
    (json/generate-stream body (io/writer output-stream) options)))
 
;; the year long yak is shaved in 8 lines by providing a custom serialiser for IReduceInits…
(extend-type IReduceInit
  cheshire.generate/JSONable
  (to-json [^IReduceInit results ^JsonGenerator jg]
    (.writeStartArray jg)
    (let [rf (fn [_ ^IPersistentMap m]
               (cheshire.generate/encode-map m jg))]
      (reduce rf nil results))
    (.writeEndArray jg)))

;; at this point I can wrap the result from next.jdbc/plan with ->JsonStreamingResponseBody into the :body of the ring response and it will stream

编写这些功能仍然感觉需要做很多工作，适配器代码总是让我担心我错过了一种简单、惯用的方法。

于 2020-08-26T19:45:40.343 回答