MongoDB dot (.) ในชื่อคีย์

ดูเหมือนว่า mongo ไม่อนุญาตให้แทรกคีย์ที่มีเครื่องหมายจุด (.) หรือดอลลาร์ ($) แต่เมื่อฉันนำเข้าไฟล์ JSON ที่มีจุดอยู่โดยใช้เครื่องมือ mongoimport มันก็ใช้ได้ดี คนขับกำลังบ่นเกี่ยวกับการพยายามแทรกองค์ประกอบนั้น

นี่คือลักษณะของเอกสารในฐานข้อมูล:

{
    "_id": {
        "$oid": "..."
    },
    "make": "saab",
    "models": {
        "9.7x": [
            2007,
            2008,
            2009,
            2010
        ]
    }
}

ฉันทำสิ่งนี้ผิดทั้งหมดหรือไม่และไม่ควรใช้แฮชแมปแบบนั้นกับข้อมูลภายนอก (เช่นโมเดล) หรือฉันสามารถหลีกเลี่ยงจุดได้หรือไม่ บางทีฉันอาจจะคิดเหมือน Javascript มากเกินไป

MongoDB ไม่รองรับคีย์ที่มีจุดอยู่ดังนั้นคุณจะต้องประมวลผลไฟล์ JSON ของคุณล่วงหน้าเพื่อลบ / แทนที่ก่อนที่จะนำเข้าไม่เช่นนั้นคุณจะตั้งค่าตัวเองสำหรับปัญหาทุกประเภท

ไม่มีวิธีแก้ปัญหามาตรฐานสำหรับปัญหานี้แนวทางที่ดีที่สุดขึ้นอยู่กับสถานการณ์เฉพาะเจาะจงมากเกินไป แต่ฉันจะหลีกเลี่ยงวิธีการเข้ารหัส / ตัวถอดรหัสที่สำคัญหากเป็นไปได้เนื่องจากคุณจะยังคงจ่ายเงินในความไม่สะดวกนี้ต่อไปโดยที่การปรับโครงสร้าง JSON น่าจะเป็นค่าใช้จ่ายเพียงครั้งเดียว

ตามที่ระบุไว้ในคำตอบอื่น ๆ MongoDB ไม่อนุญาต$หรือ.ตัวอักษรที่เป็นกุญแจแผนที่เนื่องจากข้อ จำกัด ในชื่อฟิลด์ อย่างไรก็ตามตามที่กล่าวไว้ในDollar Sign Operator การ หลีกเลี่ยงข้อ จำกัด นี้ไม่ได้ป้องกันไม่ให้คุณแทรกเอกสารด้วยคีย์ดังกล่าว แต่เพียงป้องกันไม่ให้คุณอัปเดตหรือสืบค้นข้อมูล

ปัญหาของการแทนที่.ด้วย[dot]หรือU+FF0E(ตามที่กล่าวไว้ที่อื่นในหน้านี้) คือจะเกิดอะไรขึ้นเมื่อผู้ใช้ต้องการจัดเก็บคีย์อย่างถูกต้อง[dot]หรือU+FF0E?

แนวทางที่ไดรเวอร์ afMorphia ของ Fantom ใช้คือการใช้ลำดับการหลบหนีแบบ Unicode ที่คล้ายกับ Java แต่ต้องแน่ใจว่าอักขระ Escape จะถูก Escape ก่อน โดยพื้นฐานแล้วการแทนที่สตริงต่อไปนี้จะทำ (*):

\  -->  \\
$  -->  \u0024
.  -->  \u002e

การแทนที่ย้อนกลับจะเกิดขึ้นเมื่อคีย์แผนที่ถูกอ่านจาก MongoDB ในภายหลัง

หรือในรหัสแฟนทอม :

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

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

ครั้งเดียวที่ผู้ใช้ต้องทราบถึง Conversion ดังกล่าวคือเมื่อสร้างคำค้นหาสำหรับคีย์ดังกล่าว

เนื่องจากเป็นเรื่องปกติที่จะจัดเก็บdotted.property.namesในฐานข้อมูลเพื่อวัตถุประสงค์ในการกำหนดค่าฉันเชื่อว่าวิธีนี้ดีกว่าในการแบนคีย์แผนที่ดังกล่าวทั้งหมด

(*) afMorphia จริงดำเนินการเต็มรูปแบบ / Unicode ที่เหมาะสมกฎการหลบหนีดังกล่าวในไวยากรณ์หลบหนี Unicode ในชวาแต่ลำดับทดแทนอธิบายงานก็เช่นกัน

เอกสาร Mongoขอแนะนำให้แทนที่ตัวอักษรที่ผิดกฎหมายเช่น$และ.เทียบเท่ากับ Unicode ของพวกเขา

ในสถานการณ์เหล่านี้คีย์จะต้องแทนที่ $ ที่สงวนไว้และ อักขระ อักขระใด ๆ ก็เพียงพอแล้ว แต่ให้พิจารณาใช้ Unicode full width equivalents: U + FF04 (เช่น“ ＄”) และ U + FF0E (เช่น“．”)

เวอร์ชันเสถียรล่าสุด (v3.6.1) ของ MongoDB รองรับจุด (.) ในคีย์หรือชื่อฟิลด์แล้ว

ชื่อฟิลด์สามารถมีอักขระจุด (.) และดอลลาร์ ($) ได้แล้ว

วิธีแก้ปัญหาที่ฉันเพิ่งนำมาใช้ซึ่งฉันพอใจมากคือการแบ่งชื่อคีย์และค่าออกเป็นสองช่องแยกกัน ด้วยวิธีนี้ฉันสามารถทำให้ตัวละครเหมือนเดิมทุกประการและไม่ต้องกังวลกับฝันร้ายที่แยกวิเคราะห์เหล่านั้น เอกสารจะมีลักษณะดังนี้:

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

คุณยังสามารถสอบถามนี้พอเรื่องง่ายเพียงแค่ด้วยการทำfindในเขตKeyName และ KeyValue

แทนที่จะเป็น:

 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+ เสียงเป็นวิธีที่ดีที่สุด

จากเอกสาร MongoDB "the". " อักขระต้องไม่ปรากฏที่ใดก็ได้ในชื่อคีย์ " ดูเหมือนว่าคุณจะต้องใช้รูปแบบการเข้ารหัสหรือไม่ต้องทำ

คุณจะต้องหลบหนีกุญแจ เนื่องจากดูเหมือนว่าคนส่วนใหญ่ไม่รู้วิธีการหลีกเลี่ยงสตริงอย่างถูกต้องนี่คือขั้นตอน

1. เลือกอักขระหลบหนี (ควรเลือกอักขระที่ไม่ค่อยได้ใช้) เช่น. '~'
2. ในการหลบหนีอันดับแรกให้แทนที่อินสแตนซ์ทั้งหมดของอักขระหลีกด้วยลำดับบางส่วนที่นำหน้าด้วยอักขระหลีกของคุณ (เช่น '~' -> '~ t') จากนั้นแทนที่อักขระหรือลำดับที่คุณต้องการเพื่อหลีกเลี่ยงด้วยลำดับบางส่วนที่นำหน้าด้วยอักขระหลีกของคุณ . เช่น. '.' -> '~ p'
3. ในการ unescape ขั้นแรกให้ลบลำดับการหลีกออกจากอินสแตนซ์ทั้งหมดของลำดับการหลีกเลี่ยงที่สองของคุณ (เช่น '~ 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, '~')
}

คำตอบที่ปลาย แต่ถ้าคุณใช้ฤดูใบไม้ผลิและ Mongo, MappingMongoConverterฤดูใบไม้ผลิสามารถจัดการแปลงสำหรับคุณด้วย เป็นวิธีแก้ปัญหาโดย JohnnyHK แต่จัดการโดย Spring

@Autowired
private MappingMongoConverter converter;

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

หาก Json ที่จัดเก็บของคุณคือ:

{ "axxxb" : "value" }

ผ่าน Spring (MongoClient) จะอ่านว่า:

{ "a.b" : "value" }

ฉันใช้การหลีกเลี่ยงต่อไปนี้ใน 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
])

ดังที่ผู้ใช้รายอื่นกล่าวถึงการเข้ารหัส / ถอดรหัสสิ่งนี้อาจเป็นปัญหาได้ในอนาคตดังนั้นจึงอาจง่ายกว่าที่จะแทนที่คีย์ทั้งหมดที่มีจุด นี่คือฟังก์ชันเรียกซ้ำที่ฉันสร้างขึ้นเพื่อแทนที่ปุ่มด้วย "." เหตุการณ์:

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 ไม่อนุญาตให้ใช้ในคีย์

สำหรับ 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 เพื่อบันทึก Object / Array มีชื่อคีย์มีจุดจากนั้นแยกวิเคราะห์สตริงเป็น Object ด้วย JSON.parse เพื่อประมวลผลเมื่อได้รับข้อมูลจากฐานข้อมูล

วิธีแก้ปัญหาอื่น: ปรับโครงสร้างสคีมาของคุณเช่น:

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

MongoDB ล่าสุดรองรับคีย์ที่มีจุด แต่ java MongoDB-driver ไม่รองรับ ดังนั้นเพื่อให้ใช้งานได้ใน Java ฉันจึงดึงโค้ดจากgithub repo ของ java-mongo-driverและทำการเปลี่ยนแปลงตามในฟังก์ชัน isValid Key ของพวกเขาสร้าง jar ใหม่จากมันโดยใช้ตอนนี้

แทนที่จุด ( .) หรือดอลลาร์ ( $) ด้วยอักขระอื่น ๆ ที่จะไม่ใช้ในเอกสารจริง และคืนค่าจุด ( .) หรือดอลลาร์ ( $) เมื่อดึงเอกสาร กลยุทธ์จะไม่ส่งผลต่อข้อมูลที่ผู้ใช้อ่าน

คุณสามารถเลือกตัวละครจากตัวละครทุกตัว

สิ่งที่แปลกคือการใช้ mongojs ฉันสามารถสร้างเอกสารด้วยจุดหากฉันตั้งค่า _id ด้วยตัวเอง แต่ฉันไม่สามารถสร้างเอกสารได้เมื่อสร้าง _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 ซึ่งต้องมีการเข้าถึงและเปรียบเทียบคีย์ซึ่งจะทำให้เกิดข้อผิดพลาด ฉันได้เรียนรู้วิธีที่ยากแล้วโปรดอย่าทำซ้ำสำหรับผู้ที่เริ่มต้น

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

พบในข้อความแสดงข้อผิดพลาด หากคุณใช้anaconda(ค้นหาไฟล์ผู้สื่อข่าวหากไม่มี) เพียงแค่เปลี่ยนค่าจากcheck_keys = Trueเป็นFalseในไฟล์ที่ระบุไว้ด้านบน มันจะได้ผล!