增删改查操作

在此页面上

键值对符号

创建文档
查询缓存
读取
正在更新
删除
写关注
带点/句点 (.) 和美元符号 ($) 的字段名
关于 BSON 符号类型的说明

CRUD 操作涉及创建、读取、更新和删除文档。

键值对符号

键值对出现在 MongoDB Ruby 驱动程序的许多不同上下文中，并且在如何标记键值对方面存在一些语法差异，具体取决于您使用的 Ruby 版本。

构建文档时，以下语法对于 Ruby 1.9 及更高版本是可以接受且正确的：

document = { name: "Harriet", age: 36 }

如果您使用的是 Ruby 2.2 或更高版本，则可以选择将密钥括在引号中。

document = { "name": "Harriet", "age": 36 }

如果您需要使用以 $开头的任何 MongoDB 操作符，例如$set 、 $gte或$near ，则必须将其括在引号中。 If you're using Ruby version 2.2 or greater, you can notate it as follows:

collection.update_one({ name: "Harriet" }, { "$set": { age: 42 } })

如果您使用的是早期版本的 Ruby，请使用 hashRocket 符号：

collection.update_one({ name: "Harriet" }, { "$set" => { age: 42 } })

键值对的带引号字符串和哈希火箭适用于任何版本的 Ruby：

collection.update_one({ "name" => "Harriet" }, { "$set" => { age: 42 } })

创建文档

要将文档插入集合，请在客户端上选择一个集合并调用insert_one或insert_many 。

插入操作会返回一个Mongo::Operation::Result对象，该对象为您提供有关插入本身的信息。

在 MongoDB 2.6 及更高版本上，如果插入失败，则会引发异常，因为使用了写入命令。

在 MongoDB 2.4上，仅当插入失败且写关注为1或更高时才会引发异常。

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
result = client[:artists].insert_one( { :name => 'FKA Twigs' } )
result.n # returns 1, because 1 document was inserted.
result = client[:artists].insert_many([
  { :name => 'Flying Lotus' },
  { :name => 'Aphex Twin' }
])
result.inserted_count # returns 2, because 2 documents were inserted.

指定一个`Decimal128` 数字

版本 3.4 中的新增功能。

十进制128是一种 BSON数据类型，它采用基于128位十进制的浮点值，能够模拟精确精度的十进制舍入。此功能适用于处理货币数据（例如财务和税务计算）的应用程序。

以下示例将类型为的值插入到名为Decimal128 priceinventory的collection的字段中：

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'test')
price = BSON::Decimal128.new("428.79")
client[:inventory].insert_one({ "_id" => 1,
                                "item" => "26 inch monitor",
                                "price" => price })

上述操作生成以下文档：

{ "_id" : 1, "item" : "26 inch monitor", "price" : NumberDecimal("428.79") }

您还可以从 Ruby BigDecimal对象或使用Decimal128.from_string()创建Decimal128对象。

big_decimal = BigDecimal.new(428.79, 5)
price = BSON::Decimal128.new(big_decimal)
# => BSON::Decimal128('428.79')
price = BSON::Decimal128.from_string("428.79")
# => BSON::Decimal128('428.79')

查询缓存

Ruby 驱动程序提供查询缓存。启用后，查询缓存将保存查找和聚合查询的结果，并在再次执行相同查询时返回这些保存的结果。

要了解有关查询缓存的更多信息，请访问查询缓存教程。

读取

Ruby 驱动程序为在collection上使用find方法进行查询提供了一个流畅的接口。find方法有多个可用选项。

仅在迭代结果时才会对服务器延迟执行查询 - 此时将分派查询并返回Mongo::Cursor 。

要查找给定筛选器的所有文档，请使用以下查询调用find ：

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
client[:artists].find(:name => 'Flying Lotus').each do |document|
  #=> Yields a BSON::Document.
end

要查询嵌套文档，请使用点表示法按嵌套顺序指定键。

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
client[:artists].find("records.releaseYear": 2008).each do |document|
  #=> Yields a BSON::Document.
end

旧版`$query` 事务语法

此用法已弃用。

find方法允许在第一个参数中使用旧版$query语法提供查询和选项：

collection.find(:'$query' => {name: 'Mr. Smith'})
# Equivalent to:
collection.find(name: 'Mr. Smith')
collection.find(:'$query' => {name: 'Mr. Smith'}, :'$sort' => {age: 1})
# Equivalent to:
collection.find(name: 'Mr. Smith').sort(age: 1)

针对 MongoDB 3.2 或更高版本执行查询时，驱动程序将使用适合相关服务器版本的协议，根据需要自动将查询转换为 find 命令或 OP_MSG 有效负载。

查询选项

要向查询添加选项，请在find方法之后链接适当的方法。请注意，底层对象Mongo::Collection::View是不可变的，每次方法调用后都会返回一个新对象。

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
documents = client[:artists].find(:name => 'Flying Lotus').skip(10).limit(10)
documents.each do |document|
  #=> Yields a BSON::Document.
end

以下是查询时可以添加的可用选项的完整列表，以及作为示例的相应方法。

选项

说明

allow_disk_use

设置为 true 时，服务器可以在执行查找操作时将临时数据写入磁盘。此选项仅在 MongoDB Server 4.4 及更高版本上可用。

allow_partial_results

用于分片集群。如果分片已关闭，则允许查询从运行的分片返回结果，可能仅获取结果的一部分。

batch_size(Integer)

指定游标在每个GETMORE操作中返回的每批处理文档的大小。

comment(String)

为查询添加注释。

explain(**opts)

返回查询的查询计划。使用符号键通过关键字参数传递解释选项。

# All server versions - default explain behavior
client[:artists].find.explain
# MongoDB 3.0 and newer
client[:artists].find.explain(verbosity: :query_planner)
client[:artists].find.explain(verbosity: :execution_stats)
client[:artists].find.explain(verbosity: :all_plans_execution)
# Alternative syntax using camel case
client[:artists].find.explain(verbosity: "queryPlanner")
client[:artists].find.explain(verbosity: "executionStats")
client[:artists].find.explain(verbosity: "allPlansExecution")
# MongoDB 2.6
client[:artists].find.explain(verbose: true)

解释操作支持:session和:read （针对读取偏好（read preference））选项。要为单个解释操作指定这些选项，必须将它们传递给find方法，如下所示：

client[:artists].find({}, session: session).explain
client[:artists].find({}, read: {mode: :secondary_preferred}).explain

如果在客户端或集合上指定了读取偏好选项，则该选项将传递给解释操作：

client[:artists, read: {mode: :secondary_preferred}].find.explain

请注意，创建collection对象时不接受会话选项。

该解释命令不支持传递读关注（read concern）选项。如果在客户端或collection级别指定了读关注（read concern），或者将读关注（read concern）指定为查找选项，则驱动程序不会将其传递给解释命令。

服务器为explain命令返回的信息因服务器版本和部署拓扑结构而异。驱动程序的explain方法会返回服务器提供的所有内容。

“explain”方法的返回值不是驱动程序公共API的一部分，而是取决于服务器版本和部署拓扑结构。

hint(Hash)

为查询提供要使用的索引提示。

let(Hash)

映射要在查询中使用的变量。

limit(Integer)

将返回文档的数量限制为提供的值。

max_scan(Integer)

设置在执行完整集合扫描时要扫描的最大文档数。从 MongoDB 服务器版本 4.0 开始已弃用。

max_time_ms(Integer)

允许查询运行的最长时间（以毫秒为单位）。

no_cursor_timeout

MongoDB 会在 10 分钟后自动关闭不活动的游标。调用此函数可让游标在服务器上无限期地保持打开状态。

projection(Hash)

指定要从结果中包含或排除的字段。

client[:artists].find.projection(:name => 1)

read(Hash)

仅更改此查询的读取偏好（read preference）。

client[:artists].find.read(:mode => :secondary_preferred)

session(Session)

要使用的会话。

show_disk_loc(Boolean)

指示结果还包括磁盘上文档的位置。

skip(Integer)

跳过结果中提供的文档数量。

snapshot

在快照模式下执行查询。从 MongoDB Server 版本 4.0 开始已弃用。

sort(Hash)

指定查询的排序条件。

client[:artists].find.sort(:name => -1)

其他查询操作

count_documents: 获取与过滤器匹配的文档总数或集合中的文档总数。

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
client[:artists].find(:name => 'Flying Lotus').count_documents

estimated_document_count

获取collection中的文档大致数量。

请注意，与count_documents不同， estimated_document_count不接受筛选器。

count服务器命令用于实施estimated_document_count 。更多信息可通过Count: Behaviour找到。

由于 MongoDB 版本 5.0.0-5.0.7 中的疏忽， estimated_document_count在其实现中使用的count命令未包含在 Stable API v1 中。因此，使用具有estimated_document_count的 Stable API 的用户建议将其服务器版本升级到 5.0.8+ 或设置api_strict: false ，以避免出现错误。

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
client[:artists].estimated_document_count

count

获取与筛选器匹配的文档的大致数量，或集合中文档的大致数量。

已弃用： count方法已弃用，并且在事务中不起作用。请使用count_documents获取可能与筛选器匹配的文档的确切计数，或使用estimated_document_count获取集合中文档的大致数量。

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
client[:artists].find(:name => 'Flying Lotus').count

distinct: 过滤掉具有重复值的文档。相当于 SQL distinct子句。

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
client[:artists].find.distinct(:name )

可追加游标

对于固定大小集合，可以使用可追加游标，该游标在客户端耗尽初始游标中的结果后仍保持打开状态。以下代码示例展示了如何使用可追加游标：

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
client[:artists].drop
client[:artists, capped: true, size: 512].create
result = client[:artists].insert_many([
  { :name => 'Flying Lotus' },
  { :name => 'Aphex Twin' }
])
enum = client[:artists].find({}, cursor_type: :tailable_await).to_enum
while true
  doc = enum.next
  # do something
  sleep(1)
end

读关注 (read concern)

可以在客户端或集合上设置读关注：

client = Mongo::Client.new(['localhost:14420'], database: 'music',
  read_concern: {level: :local})
client['collection'].find.to_a
collection = client['collection', read_concern: {level: :majority}]
collection.find.to_a

该驱动程序当前不支持在单个查询上设置读关注（read concern）。

可以在启动事务时指定读关注。当事务处于活动状态时，将忽略在客户端或集合上指定的任何读关注。

使用通用命令助手时，可以将读关注指定为命令的一部分：

client.database.command(dbStats: 1, readConcern: {level: :majority})

读取偏好

读取偏好决定了可以向其发送查询或命令的候选副本集成员。它们由指定为符号的模式、称为tag_sets的哈希数组、 hedge选项（指定对冲读行为的哈希）以及两个计时选项组成： local_threshold和server_selection_timeout 。

local_threshold: 定义最近的服务器和可以向其发送操作的合适服务器之间的延迟窗口上限（以秒为单位）。默认值为 15 毫秒或 0.015 秒。
server_selection_timeout: 定义在抛出异常之前阻止服务器选择的时间。默认值为 30,000 毫秒或 30 秒。

注意

读取偏好（read preference）不适用于独立运行的实例部署。当客户端连接到独立运行的实例时，任何应用程序指定的读取偏好（read preference）都将被忽略。

有关用于选择服务器的算法的更多信息，请参阅选择文档，可在MongoDB Server Github。

读取偏好（read preference）可以设置为客户端上的选项，也可以在数据库上运行命令时传递选项：

# Set read preference on a client, used for all operations
client = Mongo::Client.new([ '127.0.0.1:27017' ],
                           read: { mode: :secondary,
                                   tag_sets: [ { 'dc' => 'nyc' } ]
                                  } )
# Set read preference for a given command
client.database.command( { dbStats: 1 }, read: { mode: secondary,
                                                     tag_sets: [ { 'dc' => 'nyc' } ] } )

还可以使用with方法为collection上的特定操作设置读取偏好（read preference）：

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
artists = client[:artists]
artists.with(:read => { :mode => :primary_preferred }).find.to_a

模式

有五种可能的读取偏好模式： :primary 、 :secondary 、 :primary_preferred 、 :secondary_preferred和 ``:nearest``。请参阅MongoDB 手册中的读取偏好文档，了解这些模式的说明。

注意

当客户端使用:direct_connection Ruby 选项或directConnection URI 选项直接连接到服务器时，读取偏好（read preference）模式会自动设置为:primary_preferred ，以允许对从节点执行读取操作。如果应用程序指定了:primary读取偏好（read preference）模式，该模式将自动转换为:primary_preferred 。如果指定了其他读取偏好（read preference）模式，则会将其原封不动地传递到服务器。

标签集

tag_sets参数是标签集的有序列表，用于限制服务器的选择资格，例如数据中心感知。有关标签集的解释，请参阅MongoDB 手册中的读取偏好文档。

读取偏好（read preference）标签集 (T) 与服务器标签集 (S) 匹配 — 或者同等地，服务器标签集 (S) 与读取偏好（read preference）标签集 (T) 匹配 — 如果 T 是 S 的子集。

例如，读取偏好标签集{ dc: 'ny', rack: 2 }与具有标签集{ dc: 'ny', rack: 2, size: 'large' }的从节点服务器匹配。

作为空文档的标签集匹配任何服务器，因为空标签集是任何标签集的子集。这意味着默认tag_sets参数[{}]匹配所有服务器。

对冲

hedge参数是一个哈希值，用于指定服务器是否应使用对冲读。通过对冲读，分片集群可以将读取操作路由到两个副本集成员，并从第一个响应者返回结果。

hedge选项只能在非主节点读取偏好（read preference）上指定。它必须以哈希形式提供，并将键enabled设置为true或false 。

client = Mongo::Client.new(
  [ '127.0.0.1:27017' ],
  read: { mode: :secondary, hedge: { enabled: true } },
)

有关对冲读的更多信息，请参阅MongoDB 手册。

注意

hedge选项仅适用于 MongoDB Server 4.4 及更高版本。尝试在较旧的服务器版本上使用此选项将导致错误。

正在更新

可以通过执行单个或多个更新，或使用$findAndModify命令来更新文档。

update_one

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
artists = client[:artists]
result = artists.find(:name => 'Goldie').update_one("$inc" => { :plays =>  1 } )
result.n # Returns 1.
result = artists.update_one( { :name => 'Goldie' }, { "$inc" => { :plays =>  1 } } )
result.n # Returns 1.

update_many

result = artists.find(:label => 'Hospital').update_many( "$inc" => { :plays =>  1 } )
result.modified_count # Returns the number of documents that were updated.
result = artists.update_many( { :label => 'Hospital' }, { "$inc" => { :plays =>  1 } } )
result.modified_count # Returns the number of documents that were updated.

replace_one

result = artists.find(:name => 'Aphex Twin').replace_one(:name => 'Richard James')
result.modified_count # Returns 1.
result = artists.replace_one( { :name => 'Aphex Twin' }, { :name => 'Richard James' } )
result.modified_count # Returns 1.

要更新文档并通过$findAndModify返回文档，请使用提供的三个助手之一： find_one_and_delete 、 find_one_and_replace或find_one_and_update 。您可以选择在修改之前或之后返回文档。

find_one_and_delete

client = Mongo::Client.new( [ '127.0.0.1:27017' ], :database => 'music')
artists = client[:artists]
artists.find(:name => 'José James').find_one_and_delete # Returns the document.

find_one_and_replace

doc = artists.find(:name => 'José James').find_one_and_replace(:name => 'José')
doc # Return the document before the update.
doc = artists.find_one_and_replace({ :name => 'José James' }, { :name => 'José' })
doc # Return the document before the update.
doc = artists.find(:name => 'José James').
  find_one_and_replace( { :name => 'José' }, :return_document => :after )
doc # Return the document after the update.

find_one_and_update

doc = artists.find(:name => 'José James').
  find_one_and_update( '$set' => { :name => 'José' } )
doc # Return the document before the update.
doc = artists.find_one_and_update( { :name => 'José James' }, { '$set' => { :name => 'José' } } )
doc # Return the document before the update.

UpdateOptions

要向更新命令添加选项，请在选项哈希参数中将它们指定为键值对。

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
artists = client[:artists]
artists.indexes.create_one(name: 1)
# Force the server to use the name index to perform this operation
result = artists.update_one(
  { :name => 'Goldie' },
  { "$inc" => { :plays =>  1 } },
  { hint: { name: 1 } }
)
result.n # Returns 1.

以下是可添加到更新操作的选项列表，其中包括update_one 、 update_many 、 replace_one 、 find_one_and_delete 、 find_one_and_update和find_one_and_replace 。

选项	说明
`array_filters`	筛选器文档的数组，用于确定针对数组字段的更新操作要修改哪些数组元素。
`bypass_document_validation`	是否在写入文档之前跳过文档级验证。
`collation`	指定在比较符合特定语言约定的字符串时使用的一组规则。
`hint`	用于此操作的索引。可以指定为哈希值（例如 { _id: 1 }）或作为字符串（例如 “_id_”）。在 MongoDB Server 版本 4.2 及更高版本上支持`update_one` 、 `update_many`和`replace_one`命令，在服务器版本 4.4 及更高版本上支持`find_one_and_delete` 、 `find_one_and_update`和`find_one_and_replace`命令。
`let(Hash)`	用于此操作的变量映射。
`projection`	要在操作结果中排除或包含的字段（仅适用于`find_one_and_delete` 、 `find_one_and_replace`和`find_one_and_update`命令）。
`return_document`	一个符号，指定是按更新前还是更新后的原样返回更新后的文档。电势值为`:before`或`:after` 。（仅适用于`find_one_and_update`和`find_one_and_replace`命令）。
`sort`	如何对查找和修改命令的结果进行排序。指定为哈希键值对，其中键是要排序的字段名称，值为 1 或 -1，指定按升序或降序排序（仅适用于`find_one_and_delete` 、 `find_one_and_replace`和`find_one_and_update`命令）。
`session`	用于此操作的会话。
`upsert`	如果文档不存在，是否进行更新或插入。不能用于`find_one_and_delete`操作。

有关更新选项的更多信息，请参阅有关以下命令的 MongoDB Server 文档：

删除

delete_one

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
artists = client[:artists]
result = artists.find(:name => 'Björk').delete_one
result.deleted_count # Returns 1.
result = artists.delete_one(:name => 'Björk')
result.deleted_count # Returns 1.

delete_many

result = artists.find(:label => 'Mute').delete_many
result.deleted_count # Returns the number deleted.
result = artists.delete_many(:label => 'Mute')
result.deleted_count # Returns the number deleted.

DeleteOptions

要向删除命令添加选项，请在选项哈希参数中将它们指定为键值对。

client = Mongo::Client.new([ '127.0.0.1:27017' ], :database => 'music')
artists = client[:artists]
artists.indexes.create_one(name: 1)
# Force the server to use the name index to perform this operation
result = artists.find(:name => 'Björk').delete_one(hint: { name: 1 })
result.deleted_count # Returns 1.

以下是可添加到delete_one和delete_many操作的可用选项的完整列表。

选项	说明
`collation`	指定在比较符合特定语言约定的字符串时使用的一组规则。
`hint`	用于此操作的索引。可以指定为哈希值（例如 { _id: 1 }）或作为字符串（例如 “_id_”）。受 MongoDB Server 4.4 及更高版本支持。
`let(Hash)`	用于此操作的变量映射。
`session`	用于此操作的会话。

有关更新选项的更多信息，请参阅有关删除命令的 MongoDB 服务器文档。

写关注

MongoDB 中的所有写入操作都是在写关注下执行的，写关注是 MongoDB 为特定写入请求的确认级别。有关写关注的更多一般信息，请参阅MongoDB 手册。

Ruby 驱动程序支持在客户端、collection、会话（针对该会话上的事务）、事务、GridFS 存储桶和写入流级别以及通过Database#command手动发出命令时指定写关注（write concern）。

从驱动程序版本 2.10 开始，所有接受写关注（write concern）的驱动程序对象都通过:write_concern选项执行此操作，应为该选项提供带有写关注（write concern）选项的哈希值。不推荐使用:write选项。在驱动程序版本 2.9 及更低版本中，客户端、collection 和 GridFS 对象采用:write选项中的写关注（write concern）选项，而会话和事务对象采用:write_concern选项。

以下是将写关注（write concern）传递给客户端和collection对象的一些示例。可以在构造新的客户端和collection对象时提供:write_concern选项，也可以向#with方法提供该选项。

GridFS 页面上提供了GridFS示例。

client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'music',
  write_concern: {w: 2})
alt_client = client.with(write_concern: {w: :majority})
collection = client[:artists, write_concern: {w: 3}]
alt_collection = collection.with(write_concern: {w: :majority})
# Uses w: 3
collection.insert_one({name: 'SUN Project'})
# Uses w: :majority
alt_collection.insert_one({name: 'SUN Project'})

驱动程序版本 2.9 及更早版本通过:write选项接受客户端和collection级别的写关注（write concern）。为了向后兼容，仍支持此用法，但已弃用：

client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'music',
  write: {w: 2})
alt_client = client.with(write: {w: :majority})
collection = client[:artists, write: {w: 3}]
alt_collection = collection.with(write: {w: :majority})

如果同时提供了:write和:write_concern选项，则它们的值必须相同，否则将引发异常：

# OK
client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'music',
  write_concern: {w: 3}, write: {w: 3})
# Error
client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'music',
  write_concern: {w: 3}, write: {w: :majority})

当使用#with方法更改客户端或collection上的选项时，由于命名差异，最后提供的选项获胜：

client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'music',
  write_concern: {w: 2})
alt_client = client.with(write: {w: 3})
alt_client.options[:write]
# => {"w"=>3}
alt_client.options[:write_concern]
# => nil

使用事务时，根据commit_transaction abort_transaction事务规范，写关注仅在和操作中发送到服务器。写关注可以通过with_transaction或start_transaction调用中的:write_concern选项设置，也可以通过会话对象上的default_transaction_options选项设置。如果这些都未设置，则使用客户端的写关注；请注意，事务会忽略其操作中涉及的集合的写关注。请注意，将写关注设置为事务选项时，任何驱动程序版本都无法识别:write选项。

client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'music',
  write_concern: {w: 2})
collection = client[:artists, write_concern: {w: :majority}]
session = client.start_session
session.with_transaction do
  collection.insert_one({test: 1}, session: session)
  # Uses w: 2 when committing
end
session = client.start_session(default_transaction_options:
  {write_concern: {w: 3})
)
session.with_transaction do
  collection.insert_one({test: 1}, session: session)
  # Uses w: 3 when committing
end
session = client.start_session
session.with_transaction(write_concern: {w: 3}) do
  collection.insert_one({test: 1}, session: session)
  # Uses w: 3 when committing
end

当继承写关注（write concern）时，继承适用于整个写关注（write concern）哈希，而不是单个元素。例如，在以下情况下不会继承j: true ：

client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'music',
  write_concern: {w: 1, j: true})
collection = client[:artists, write_concern: {w: 2}]
collection.write_concern.options
# => #<Mongo::WriteConcern::Acknowledged:0x47289650367880 options={:w=>2}>

虽然 CRUD 操作接受选项哈希，但目前无法识别:write_concern选项：

client = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'music',
  write_concern: {w: 2})
collection = client[:artists, write_concern: {w: :majority}]
# Still uses w: :majority
collection.insert_one({name: 'SUN Project'}, write_concern: {w: 1})

最简单的解决方法是使用#with获取具有所需写关注（write concern）的新collection实例：

# Uses w: 1
collection.with(write_concern: {w: 1}).insert_one(name: 'SUN Project')

也可以在Database#command中手动指定写关注（write concern）：

client.database.command(create: 'foo-collection', writeConcern: {w: :majority})

请注意，此处的 writeConcern 是操作的一部分而不是选项，并且语法是 MongoDB Server 可识别的驼峰式大小写语法，而不是 Ruby 使用的下划线语法。

带点/句点 (.) 和美元符号 ($) 的字段名

从mongo Ruby驱动程序版本 2.18.0 开始，可以处理以美元符号 ($) 开头的字段和包含点/句点 (.) 的字段。在驱动程序版本2.17.0及更早版本中，任何尝试使用虚线或美元字段的操作都会导致引发IllegalKey错误。 MongoDBDocs有关使用这些类型字段的更多信息，请参阅有关带句点 (.) 和美元符号 ($) 的字段名称的。

关于 BSON 符号类型的说明

由于 BSON 规范已弃用 BSON 符号类型，因此单独使用时， bson gem 会将 Ruby 符号序列化为 BSON 字符串。但是，为了保持与旧数据集的向后兼容性，Ruby 驱动程序会覆盖此行为，将 Ruby 符号序列化为 BSON 符号。这是指定查询包含 BSON 符号作为字段的文档所必需的。尽管如此，带有符号类型字段的新文档不应存储在数据库中；而应使用字符串字段。

要覆盖默认行为并将驱动程序配置为将符号值编码为字符串，请在项目中包含以下代码片段：

class Symbol
  def bson_type
    BSON::String::BSON_TYPE
  end
end

后退

处理数据

来年

批量写入