键名中的 MongoDB 点 (.）

MongoDB不支持带有点的键，因此您必须在导入之前预处理JSON文件以删除/替换它们，否则您将为各种问题做好准备。

此问题没有标准的解决方法，最佳方法过于依赖于具体情况。但如果可能的话，我会避免任何关键的编码器/解码器方法，因为您将继续永久支付这种不便，其中 JSON 重组可能是一次性成本。

正如其他答案中提到的，由于字段名称的限制，MongoDB不允许$或.字符作为映射键。但是，如美元符号运算符中所述 转义此限制不会阻止您插入具有此类键的文档，它只会阻止您更新或查询它们。

简单地用[dot]或U+FF0E替换.(如本页其他地方所述(的问题是，当用户合法地想要存储密钥[dot]或U+FF0E时会发生什么？

Fantom的afMorphia驱动程序采取的一种方法是使用类似于Java的Unicode转义序列，但首先确保转义字符。实质上，进行了以下字符串替换 (*(：

'  -->  ''
$  -->  'u0024
.  -->  'u002e

当随后从MongoDB读取映射键时，将进行反向替换。

或者在Fantom代码中：

Str encodeKey(Str key) {
    return key.replace("''", "''''").replace("'$", "''u0024").replace(".", "''u002e")
}
Str decodeKey(Str key) {
    return key.replace("''u002e", ".").replace("''u0024", "'$").replace("''''", "''")
}

用户唯一需要了解此类转换的时间是在为此类键构造查询时。

鉴于出于配置目的将dotted.property.names存储在数据库中是很常见的，我认为这种方法比简单地禁止所有此类映射键更可取。

(*( afMorphia 实际上执行完整/正确的 Unicode 转义规则，如 Java 中的 Unicode 转义语法中所述，但所描述的替换序列也同样有效。

MongoDB的最新稳定版本(v3.6.1(现在确实支持键或字段名称中的点(.(。

字段名称现在可以包含点 (.( 和美元 ($( 字符

Mongo 文档建议将非法字符(如 $ 和 .(替换为它们的 unicode 等效字符。

在这些情况下，键需要替换保留的 $ 和 . 字符。任何字符都足够，但请考虑使用 Unicode 全角等效项：U+FF04(即"$"(和 U+FF0E(即"."(。

我刚刚实现的一个我非常满意的解决方案涉及将键名称和值拆分为两个单独的字段。这样，我可以保持字符完全相同，而不必担心任何解析噩梦。该文档如下所示：

{
    ...
    keyName: "domain.com",
    keyValue: "unregistered",
    ...
}

您仍然可以非常简单地查询，只需对字段 keyName和keyValue 执行find即可。

所以代替：

 db.collection.find({"domain.com":"unregistered"})

这实际上不会按预期工作，您将运行：

db.collection.find({keyName:"domain.com", keyValue:"unregistered"})

它将返回预期的文档。

可以尝试在键中使用哈希而不是值，然后将该值存储在 JSON 值中。

var crypto = require("crypto");   
function md5(value) {
    return crypto.createHash('md5').update( String(value) ).digest('hex');
}
var data = {
    "_id": {
        "$oid": "..."
    },
    "make": "saab",
    "models": {}
}
var version = "9.7x";
data.models[ md5(version) ] = {
    "version": version,
    "years" : [
        2007,
        2008,
        2009,
        2010
    ]
}

然后，稍后将使用哈希访问模型。

var version = "9.7x";
collection.find( { _id : ...}, function(e, data ) {
    var models = data.models[ md5(version) ];
}

现在支持它

MongoDb 3.6 及更高版本支持字段名称中的点和美元。见下文 JIRA：https://jira.mongodb.org/browse/JAVA-2810

将Mongodb升级到3.6+听起来是最好的方法。

您需要转义密钥。由于似乎大多数人不知道如何正确转义字符串，因此步骤如下：

选择
1. 转义字符(最好选择很少使用的字符(。例如。'~'
2. 要进行转义，请首先将转义字符的所有实例替换为一些以转义字符为前缀的序列(例如"~"->"~t"(，然后将您需要转义的任何字符或序列替换为以转义字符为前缀的某个序列。例如。'." -> '~p'
3. 要取消转义，首先从第二个转义序列的所有实例中删除转义序列(例如"~p"->"."(，然后将转义字符序列转换为单个转义字符(例如"~s"->"~"(

另外，请记住，mongo 也不允许键以"$"开头，所以你必须在那里做类似的事情

下面是一些执行此操作的代码：

// returns an escaped mongo key
exports.escape = function(key) {
  return key.replace(/~/g, '~s')
            .replace(/'./g, '~p')
            .replace(/^'$/g, '~d')
}
// returns an unescaped mongo key
exports.unescape = function(escapedKey) {
  return escapedKey.replace(/^~d/g, '$')
                   .replace(/~p/g, '.')
                   .replace(/~s/g, '~')
}

在MongoDB文档中，"'."字符不得出现在键名中的任何位置"。 看起来你必须想出一个编码方案，或者没有。

一个较晚的答案，但如果你使用 Spring 和 Mongo，Spring 可以用 MappingMongoConverter 为你管理转换。这是JohnnyHK的解决方案，但由Spring处理。

@Autowired
private MappingMongoConverter converter;
@PostConstruct
public void configureMongo() {
 converter.setMapKeyDotReplacement("xxx");
}

如果存储的 JSON 是 ：

{ "axxxb" : "value" }

通过Spring(MongoClient(，它将被读取为：

{ "a.b" : "value" }

正如另一位用户所提到的，编码/解码将来可能会出现问题，因此替换所有带有点的键可能更容易。这是我制作的一个递归函数，用于将键替换为"."出现次数：

def mongo_jsonify(dictionary):
    new_dict = {}
    if type(dictionary) is dict:
        for k, v in dictionary.items():
            new_k = k.replace('.', '-')
            if type(v) is dict:
                new_dict[new_k] = mongo_jsonify(v)
            elif type(v) is list:
                new_dict[new_k] = [mongo_jsonify(i) for i in v]
            else:
                new_dict[new_k] = dictionary[k]
        return new_dict
    else:
        return dictionary
if __name__ == '__main__':
    with open('path_to_json', "r") as input_file:
        d = json.load(input_file)
    d = mongo_jsonify(d)
    pprint(d)

您也可以修改此代码以替换"$"，因为这是 mongo 不允许在键中使用的另一个字符。

我在JavaScript中对每个对象键使用以下转义：

key.replace(/''/g, '''''').replace(/^'$/, '''$').replace(/'./g, '''_')

我喜欢它的是它只替换了开头的$，并且不使用在控制台中使用可能很棘手的 unicode 字符。 对我来说，_比 unicode 字符更具可读性。它也不会用另一组(Unicode(替换一组特殊字符($，.(。但用传统的'适当地逃脱了.

不完美，但在大多数情况下都有效：用其他字符替换禁止的字符。由于它位于键中，因此这些新字符应该相当罕见。

/** This will replace ' with ⍀, ^$ with '₴' and dots with ⋅  to make the object compatible for mongoDB insert. 
Caveats:
    1. If you have any of ⍀, ₴ or ⋅ in your original documents, they will be converted to '$.upon decoding. 
    2. Recursive structures are always an issue. A cheap way to prevent a stack overflow is by limiting the number of levels. The default max level is 10.
 */
encodeMongoObj = function(o, level = 10) {
    var build = {}, key, newKey, value
    //if (typeof level === "undefined") level = 20     // default level if not provided
    for (key in o) {
        value = o[key]
        if (typeof value === "object") value = (level > 0) ? encodeMongoObj(value, level - 1) : null     // If this is an object, recurse if we can
        newKey = key.replace(/''/g, '⍀').replace(/^'$/, '₴').replace(/'./g, '⋅')    // replace special chars prohibited in mongo keys
        build[newKey] = value
    }
    return build
}
/** This will decode an object encoded with the above function. We assume the structure is not recursive since it should come from Mongodb */
decodeMongoObj = function(o) {
    var build = {}, key, newKey, value
    for (key in o) {
        value = o[key]
        if (typeof value === "object") value = decodeMongoObj(value)     // If this is an object, recurse
        newKey = key.replace(/⍀/g, '''').replace(/^₴/, '$').replace(/⋅/g, '.')    // replace special chars prohibited in mongo keys
        build[newKey] = value
    }
    return build
}

这是一个测试：

var nastyObj = {
    "sub.obj" : {"$dollar''backslash": "$''.end$"}
}
nastyObj["$you.must.be.kidding"] = nastyObj     // make it recursive
var encoded = encodeMongoObj(nastyObj, 1)
console.log(encoded)
console.log( decodeMongoObj( encoded) )

和结果 - 请注意，这些值不会修改：

{
  sub⋅obj: {
    ₴dollar⍀backslash: "$''.end$"
  },
  ₴you⋅must⋅be⋅kidding: {
    sub⋅obj: null,
    ₴you⋅must⋅be⋅kidding: null
  }
}
[12:02:47.691] {
  "sub.obj": {
    $dollar''backslash: "$''.end$"
  },
  "$you.must.be.kidding": {
    "sub.obj": {},
    "$you.must.be.kidding": {}
  }
}

有一些丑陋的查询方法不建议在应用程序中使用它，而不是用于调试目的(仅适用于嵌入对象(：

db.getCollection('mycollection').aggregate([
    {$match: {mymapfield: {$type: "object" }}}, //filter objects with right field type
    {$project: {mymapfield: { $objectToArray: "$mymapfield" }}}, //"unwind" map to array of {k: key, v: value} objects
    {$match: {mymapfield: {k: "my.key.with.dot", v: "myvalue"}}} //query
])

对于 PHP，我用 HTML 值代替句点。那是".".

它像这样存储在MongoDB中：

  "validations" : {
     "4e25adbb1b0a55400e030000" : {
     "associate" : "true" 
    },
     "4e25adb11b0a55400e010000" : {
       "associate" : "true" 
     } 
   } 

和 PHP 代码...

  $entry = array('associate' => $associate);         
  $data = array( '$set' => array( 'validations.' . str_replace(".", `"."`, $validation) => $entry ));     
  $newstatus = $collection->update($key, $data, $options);      

Lodash 对将允许您更改

{ 'connect.sid': 's:hyeIzKRdD9aucCc5NceYw5zhHN5vpFOp.0OUaA6' }

到

[ [ 'connect.sid',
's:hyeIzKRdD9aucCc5NceYw5zhHN5vpFOp.0OUaA6' ] ]

用

var newObj = _.pairs(oldObj);

按原样存储它并在之后转换为漂亮的

我在Livescript上写了这个例子。您可以使用 livescript.net 网站对其进行评估

test =
  field:
    field1: 1
    field2: 2
    field3: 5
    nested:
      more: 1
      moresdafasdf: 23423
  field3: 3

get-plain = (json, parent)->
  | typeof! json is 'Object => json |> obj-to-pairs |> map -> get-plain it.1, [parent,it.0].filter(-> it?).join('.)
  | _ => key: parent, value: json
test |> get-plain |> flatten |> map (-> [it.key, it.value]) |> pairs-to-obj

它将产生

{"field.field1":1,
 "field.field2":2,
 "field.field3":5,
 "field.nested.more":1,
 "field.nested.moresdafasdf":23423,
 "field3":3}

给你我的提示：你可以使用 JSON.stringify 保存 对象/数组包含键名有点，然后使用 JSON.parse 将字符串解析为 Object 以在从数据库获取数据时进行处理

另一种解决方法：重构架构，如下所示：

key : {
"keyName": "a.b"
"value": [Array]
}

最新的MongoDB确实支持带点的键，但java MongoDB驱动程序不支持。因此，为了使它在Java中工作，我从java-mongo-driver的github存储库中提取代码，并在他们的isValid Key函数中进行相应的更改，从中创建新的jar，现在使用它。

点( . ( 或 dollar( $ ( 替换为实际文档中永远不会使用的其他字符。并在检索文档时恢复点(.(或美元($(。该策略不会影响用户读取的数据。

您可以从所有字符中选择字符。

是，如果我自己设置_id，使用 mongojs，我可以创建一个带有点的文档，但是在生成_id时我无法创建文档：

确实有效：

db.testcollection.save({"_id": "testdocument", "dot.ted.": "value"}, (err, res) => {
    console.log(err, res);
});

不起作用：

db.testcollection.save({"dot.ted": "value"}, (err, res) => {
    console.log(err, res);
});

我最初认为 dat 使用点键更新文档也有效，但它将点识别为子键！

看到mongojs如何处理点(子键(，我将确保我的键不包含点。

就像@JohnnyHK提到的，请从键中删除标点符号或"."，因为当数据开始累积到更大的数据集中时，会产生更大的问题。这将导致问题，尤其是当您调用聚合运算符(如 $merge(时，它需要访问和比较会引发错误的键。我已经以艰难的方式学会了它，请不要为那些刚起步的人重复。

在我们的例子中，用户永远不会直接查询带有句点的属性。但是，它们可以由用户创建。

因此，我们首先序列化整个模型，字符串替换特定字段的所有实例。我们的周期字段可以显示在许多位置，并且无法预测数据的结构。

    var dataJson = serialize(dataObj);
    foreach(pf in periodFields) 
    {  
         var encodedPF = pf.replace(".", "ENCODE_DOT");
         dataJson.replace(pf, encodedPF);
    }

然后，在我们的数据被展平后，我们替换了编码PF的实例，以便我们可以在文件中写入解码的版本

没有人会需要一个名为ENCODE_DOT的字段，因此在我们的例子中这不是问题。

结果如下color.one 将在数据库中作为colorENCODE_DOTone

当我们编写文件时，我们将ENCODE_DOT替换为.

mongodb v5.0 开始支持 $setField，下面的示例在下面的文档中：https://www.mongodb.com/docs/manual/reference/operator/aggregation/setField/

db.inventory.aggregate( [
   { $match: { _id: 1 } },
   { $replaceWith: {
        $setField: {
           field: "price.usd",
           input: "$$ROOT",
           value: 49.99
    } } }
] )

/home/user/anaconda3/lib/python3.6/site-packages/pymongo/collection.py

在错误消息中找到它。如果您使用anaconda(如果没有，请查找相应的文件(，只需将上述文件中的值从check_keys = True更改为False即可。那就行了！