我分 1,000 个批处理从服务器获取大约 20,000 个数据集。每个数据集都是一个 JSON 对象。坚持这会产生大约 350 MB 的未压缩明文。

我的内存限制为 1GB。因此，我以追加模式将每 1,000 个 JSON 对象作为一个数组写入到一个原始 JSON 文件中。

结果是一个包含 20 个需要聚合的 JSON 数组的文件。无论如何我都需要触摸它们，因为我想添加元数据。一般Ruby Yajl Parser使这成为可能:

raw_file = File.new(path_to_raw_file, 'r')
json_file = File.new(path_to_json_file, 'w')

datasets = []
parser = Yajl::Parser.new
parser.on_parse_complete = Proc.new { |o| datasets += o }

parser.parse(datasets)

hash = { date: Time.now, datasets: datasets }
Yajl::Encoder.encode(hash, json_file)

这个解决方案的问题在哪里？问题是整个 JSON 仍然被解析到内存，我必须避免这种情况。

基本上我需要的是一个解决方案，它从一个 IO 对象解析 JSON 并同时将它们编码为另一个 IO 对象。

我以为 Yajl 提供了这个，但我还没有找到方法，它的 API 也没有给出任何提示，所以我想不会。是否有支持此功能的 JSON Parser 库？还有其他解决方案吗？

我能想到的唯一解决方案是使用IO.seek 功能。一个接一个地写入所有数据集数组 [...][...][...] 并且在每个数组之后，我回到开始并覆盖 ][ 和 ,，有效地手动连接数组。

最佳答案

为什么您不能一次从数据库中检索一条记录，根据需要对其进行处理，将其转换为 JSON，然后使用尾随/分隔逗号发送它？

如果您从一个仅包含 [ 的文件开始，然后附加所有 JSON 字符串，那么在最后一个条目上没有附加逗号，而是使用结束 ] ，你会有一个 JSON 哈希数组，并且一次只需要处理一行的值。

它会稍微慢一点(也许)，但不会影响您的系统。如果您使用阻塞/分页一次检索合理数量的记录，那么 DB I/O 会非常快。

例如，下面是一些 Sequel 示例代码的组合，以及将行提取为 JSON 并构建更大的 JSON 结构的代码:

require 'json'
require 'sequel'

DB = Sequel.sqlite # memory database

DB.create_table :items do
  primary_key :id
  String :name
  Float :price
end

items = DB[:items] # Create a dataset

# Populate the table
items.insert(:name => 'abc', :price => rand * 100)
items.insert(:name => 'def', :price => rand * 100)
items.insert(:name => 'ghi', :price => rand * 100)

add_comma = false

puts '['
items.order(:price).each do |item|
  puts ',' if add_comma
  add_comma ||= true
  print JSON[item]
end
puts "\n]"

哪些输出:

[
{"id":2,"name":"def","price":3.714714089426208},
{"id":3,"name":"ghi","price":27.0179624376119},
{"id":1,"name":"abc","price":52.51248221170203}
]

注意订单现在是按“价格”。

验证很容易:

require 'json'
require 'pp'

pp JSON[<<EOT]
[
{"id":2,"name":"def","price":3.714714089426208},
{"id":3,"name":"ghi","price":27.0179624376119},
{"id":1,"name":"abc","price":52.51248221170203}
]
EOT

结果是:

[{"id"=>2, "name"=>"def", "price"=>3.714714089426208},
 {"id"=>3, "name"=>"ghi", "price"=>27.0179624376119},
 {"id"=>1, "name"=>"abc", "price"=>52.51248221170203}]

这会验证 JSON 并证明原始数据是可恢复的。从数据库中检索到的每一行都应该是您要构建的整个 JSON 结构中最小的“bitesized”部分。

在此基础上，以下是如何读取数据库中传入的 JSON、对其进行操作，然后将其作为 JSON 文件发出:

require 'json'
require 'sequel'

DB = Sequel.sqlite # memory database

DB.create_table :items do
  primary_key :id
  String :json
end

items = DB[:items] # Create a dataset

# Populate the table
items.insert(:json => JSON[:name => 'abc', :price => rand * 100])
items.insert(:json => JSON[:name => 'def', :price => rand * 100])
items.insert(:json => JSON[:name => 'ghi', :price => rand * 100])
items.insert(:json => JSON[:name => 'jkl', :price => rand * 100])
items.insert(:json => JSON[:name => 'mno', :price => rand * 100])
items.insert(:json => JSON[:name => 'pqr', :price => rand * 100])
items.insert(:json => JSON[:name => 'stu', :price => rand * 100])
items.insert(:json => JSON[:name => 'vwx', :price => rand * 100])
items.insert(:json => JSON[:name => 'yz_', :price => rand * 100])

add_comma = false

puts '['
items.each do |item|
  puts ',' if add_comma
  add_comma ||= true
  print JSON[
    JSON[
      item[:json]
    ].merge('foo' => 'bar', 'time' => Time.now.to_f)
  ]
end
puts "\n]"

生成:

[
{"name":"abc","price":3.268814929005337,"foo":"bar","time":1379688093.124606},
{"name":"def","price":13.871147312377719,"foo":"bar","time":1379688093.124664},
{"name":"ghi","price":52.720984131655676,"foo":"bar","time":1379688093.124702},
{"name":"jkl","price":53.21477190840114,"foo":"bar","time":1379688093.124732},
{"name":"mno","price":40.99364022416619,"foo":"bar","time":1379688093.124758},
{"name":"pqr","price":5.918738444452265,"foo":"bar","time":1379688093.124803},
{"name":"stu","price":45.09391752439902,"foo":"bar","time":1379688093.124831},
{"name":"vwx","price":63.08947792357426,"foo":"bar","time":1379688093.124862},
{"name":"yz_","price":94.04921035056373,"foo":"bar","time":1379688093.124894}
]

我添加了时间戳，这样您就可以看到每一行都是单独处理的，AND 让您了解这些行的处理速度。诚然，这是一个很小的内存数据库，没有网络 I/O 可以满足，但是通过交换机到合理的数据库主机上的数据库的正常网络连接也应该非常快。告诉 ORM 以 block 的形式读取 DB 可以加快处理速度，因为 DBM 将能够返回更大的 block 以更有效地填充数据包。您必须通过试验来确定所需的 block 大小，因为它会根据您的网络、主机和记录的大小而有所不同。

在处理企业级数据库时，您的原始设计并不好，尤其是当您的硬件资源有限时。多年来，我们已经学会了如何解析大型数据库，这使得 20,000 行表显得微不足道。 VM 切片现在​​很常见，我们用它们来处理，所以它们通常是过去的 PC:具有小内存占用和极小驱动器的单个 CPU。我们不能击败它们，否则它们将成为瓶颈，因此我们必须尽可能将数据分解成最小的原子片段。

关于数据库设计的喋喋不休:在数据库中存储 JSON 是一种有问题的做法。现在的 DBM 可以生成行的 JSON、YAML 和 XML 表示，但是强制 DBM 在存储的 JSON、YAML 或 XML 字符串中进行搜索会严重影响处理速度，因此不惜一切代价避免它，除非您也有等效的查找数据在单独的字段中编入索引，以便您的搜索速度尽可能快。如果数据在单独的字段中可用，那么进行良好的数据库查询、调整 DBM 或您选择的脚本语言以及发送经过处理的数据都会变得容易得多。

关于ruby - JSON的基于流的解析和写入，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18902388/