Anahtar adında MongoDB noktası (.)

Görünüşe göre mongo, nokta (.) Veya dolar işareti ($) olan anahtarların eklenmesine izin vermiyor, ancak mongoimport aracını kullanarak içinde bir nokta içeren bir JSON dosyasını içe aktardığımda iyi çalıştı. Sürücü, bu öğeyi yerleştirmeye çalışmaktan şikayet ediyor.

Bu, belgenin veritabanında nasıl göründüğüdür:

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

Bunu tamamen yanlış mı yapıyorum ve harici verilerle (yani modeller) bunun gibi karma haritalar kullanmamalı mıyım yoksa noktadan bir şekilde kaçabilir miyim? Belki de Javascript gibi çok fazla düşünüyorum.

MongoDB, içinde nokta bulunan anahtarları desteklemez , bu nedenle, içe aktarmadan önce bunları kaldırmak / değiştirmek için JSON dosyanızı önceden işlemeniz gerekecek veya her türlü soruna karşı kendinizi hazırlamış olacaksınız.

Bu sorunun standart bir çözümü yoktur, en iyi yaklaşım durumun özelliklerine fazlasıyla bağlıdır. Ancak mümkünse herhangi bir anahtar kodlayıcı / kod çözücü yaklaşımından kaçınırım çünkü bunun zahmetini sonsuza kadar ödemeye devam edeceksiniz, çünkü bir JSON yeniden yapılandırması muhtemelen tek seferlik bir maliyet olacaktır.

Diğer cevaplarda belirtildiği gibi MongoDB izin vermiyor $ alan adlarındaki kısıtlamalar. nedeniyle harita anahtarları olarak veya karakterlere . Ancak Dolar İşareti Operatöründen Kaçmak bölümünde belirtildiği gibi bu kısıtlama, bu tür anahtarlara sahip belgeleri eklemenizi engellemez , yalnızca bunları güncellemenizi veya sorgulamanızı engeller.

Basitçe veya .ile değiştirme sorunu ( bu sayfada başka bir yerde belirtildiği gibi), kullanıcı yasal olarak anahtarı saklamak istediğinde veya ?[dot]U+FF0E[dot]U+FF0E

Fantom'un afMorphia sürücüsünün benimsediği bir yaklaşım, Java'nınkine benzer unicode kaçış dizilerini kullanmak, ancak önce kaçış karakterinin kaçmasını sağlamaktır. Temelde, aşağıdaki dize değişiklikleri yapılır (*):

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

Harita tuşları sonradan okumak kaldıklarında, bir ters yedek yapıldığı gelen MongoDB.

Veya Fantom kodunda:

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

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

Bir kullanıcının bu tür dönüşümlerden haberdar olması gereken tek zaman, bu tür anahtarlar için sorgular oluştururken.

dotted.property.namesYapılandırma amacıyla veritabanlarında depolamanın yaygın olduğu düşünüldüğünde, bu yaklaşımın tüm bu tür harita anahtarlarını yasaklamaktan daha tercih edildiğine inanıyorum.

(*) afMorphia , Java'da Unicode kaçış sözdiziminde belirtildiği gibi tam / uygun unicode kaçış kurallarını gerçekleştirir, ancak açıklanan değiştirme dizisi de aynı şekilde çalışır.

Mongo dokümanlar gibi geçersiz karakterlerle değiştirmenizi öneririz $ve .onların unicode eşdeğerleriyle.

Bu durumlarda, anahtarların ayrılmış $ ve. karakterler. Herhangi bir karakter yeterlidir, ancak Unicode tam genişlik eşdeğerlerini kullanmayı düşünün: U + FF04 (yani “＄”) ve U + FF0E (yani “．”).

MongoDB'nin en son kararlı sürümü (v3.6.1) artık tuşlarda veya alan adlarında noktaları (.) Desteklemektedir.

Alan adları artık nokta (.) Ve dolar ($) karakterleri içerebilir

Az önce uyguladığım ve gerçekten memnun olduğum bir çözüm, anahtar adını ve değerini iki ayrı alana bölmeyi içeriyor. Bu şekilde, karakterleri tamamen aynı tutabilirim ve kabusların ayrıştırılması için endişelenmem. Doktor şöyle görünür:

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

Yine de, keyName ve keyValuefind alanlarında a yaparak bunu yeterince kolay bir şekilde sorgulayabilirsiniz .

Yani bunun yerine:

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

aslında beklendiği gibi çalışmazsa, şunu çalıştırırsınız:

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

ve beklenen belgeyi döndürür.

Değer yerine anahtarda bir karma kullanmayı deneyebilir ve ardından bu değeri JSON değerinde depolayabilirsiniz.

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
    ]
}

Daha sonra hash'i kullanarak modellere erişirsiniz.

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

Şimdi destekleniyor

Mongodb 3.6 itibaren destekler noktalar ve dolar alan adlarında. Aşağıdaki JIRA'ya bakın: https://jira.mongodb.org/browse/JAVA-2810

Mongodb'unuzu 3.6'dan fazla sese yükseltmek, gitmenin en iyi yolu gibi geliyor.

Gönderen MongoDB docs " '' karakter anahtar adının hiçbir yerinde görünmemelidir ". Görünüşe göre bir kodlama şeması bulmanız veya onsuz yapmanız gerekecek.

Anahtarlardan kaçmanız gerekecek. Çoğu insan dizelerden nasıl doğru bir şekilde kurtulacağını bilmediğinden, işte adımlar:

1. bir kaçış karakteri seçin (en iyisi, nadiren kullanılan bir karakter seçmek için). Örneğin. '~'
2. Çıkmak için, önce kaçış karakterinin tüm örneklerini önüne kaçış karakterinizin eklediği bir dizi ile değiştirin (örneğin, '~' -> '~ t'), ardından kaçmak istediğiniz karakteri veya diziyi, önüne kaçış karakterinizin eklediği bir dizi ile değiştirin . Örneğin. "." -> '~ p'
3. Çıkış sırasını kaldırmak için, önce ikinci kaçış dizinizin tüm örneklerinden (örneğin '~ p' -> '.') Kaçış dizisini kaldırın, ardından kaçış karakter dizinizi tek bir çıkış karakterine dönüştürün (ör. '~ S' -> '~ ')

Ayrıca, mongo'nun anahtarların '$' ile başlamasına izin vermediğini de unutmayın, bu yüzden orada benzer bir şey yapmanız gerekir

İşte bunu yapan bazı kodlar:

// 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, '~')
}

Geç cevap, ancak Bahar ve Mongo kullanırsanız, Bahar ile dönüşümü sizin için yönetebilir MappingMongoConverter. Bu JohnnyHK tarafından sağlanan çözüm ama Spring tarafından hallediliyor.

@Autowired
private MappingMongoConverter converter;

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

Depolanan Json'unuz:

{ "axxxb" : "value" }

Bahar boyunca (MongoClient) şu şekilde okunacaktır:

{ "a.b" : "value" }

Her nesne anahtarı için JavaScript'te aşağıdaki kaçışı kullanıyorum:

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

Bununla ilgili sevdiğim şey, yalnızca $başlangıçta yerini alması ve konsolda kullanılması zor olabilecek unicode karakterleri kullanmaması. _bana göre bir unicode karakterinden çok daha okunaklı. Ayrıca, bir özel karakter kümesini ( $, .) diğeriyle (unicode) değiştirmez. Ama gelenekselden düzgün bir şekilde kaçar \.

Mükemmel değil, ancak çoğu durumda işe yarayacak: yasaklanmış karakterleri başka bir şeyle değiştirin. Anahtarlarda olduğu için, bu yeni karakterler oldukça nadir olmalıdır.

/** 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
}

İşte bir test:

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) )

ve sonuçlar - değerlerin değiştirilmediğine dikkat edin:

{
  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": {}
  }
}

Sorgulamanın çirkin bir yolu vardır, hata ayıklama amacıyla kullanmak yerine uygulamada kullanılması önerilmez (yalnızca katıştırılmış nesnelerde çalışır):

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
])

Başka bir kullanıcının da bahsettiği gibi, bunu kodlama / kod çözme gelecekte sorunlu hale gelebilir, bu nedenle nokta içeren tüm anahtarları değiştirmek muhtemelen daha kolaydır. Anahtarları 'ile değiştirmek için yaptığım özyinelemeli bir işlev. olaylar:

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'nun bir anahtarda izin vermeyeceği başka bir karakter olduğundan, bu kodu '$' ile değiştirmek için de değiştirebilirsiniz.

PHP için, dönemin HTML değerini değiştiriyorum. Bu ".".

MongoDB'de şu şekilde depolanır:

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

ve PHP kodu ...

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

Lodash çiftleri değiştirmenize izin verecek

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

içine

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

kullanma

var newObj = _.pairs(oldObj);

Olduğu gibi saklayabilir ve sonra güzele dönüştürebilirsiniz

Bu örneği Livescript'e yazdım. Bunu değerlendirmek için livecript.net web sitesini kullanabilirsiniz.

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

Üretecek

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

Size ipucu vereyim: Object / Array'i kaydetmek için JSON.stringify kullanabilirsiniz, anahtar adı noktalara sahiptir, ardından veritabanından veri alırken işlemek için dizeyi JSON.parse ile Object'e ayrıştırabilirsiniz.

Başka bir geçici çözüm: Şemanızı aşağıdaki gibi yeniden yapılandırın:

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

En son MongoDB, noktalı anahtarları destekler, ancak java MongoDB sürücüsü desteklemiyor. Bu yüzden Java'da çalışmasını sağlamak için , java-mongo-driver'ın github repo'sundan kod aldım ve isValid Key fonksiyonunda buna göre değişiklikler yaptım, şimdi onu kullanarak yeni kavanoz yarattım.

Nokta ( .) veya doları ( $) gerçek belgede asla kullanılmayacak diğer karakterlerle değiştirin. Ve noktayı ( .) veya doları ($ belgeyi alırken ) . Strateji, kullanıcının okuduğu verileri etkilemeyecektir.

Tüm karakterlerden karakteri seçebilirsiniz .

Garip olan şu ki, mongojs kullanarak, _id'yi kendim ayarlarsam noktalı bir belge oluşturabilirim, ancak _id oluşturulduğunda bir belge oluşturamıyorum:

Çalışır:

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

Çalışmıyor:

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

İlk önce bir nokta anahtarıyla bir belgeyi güncellemenin işe yaradığını düşündüm, ancak noktayı bir alt anahtar olarak tanımlıyor!

Mongojs'un noktayı (alt anahtar) nasıl işlediğini görünce, anahtarlarımın nokta içermediğinden emin olacağım.

Ne gibi @JohnnyHK sözü var, kaldır noktalama işaretleri veya yapmak '' Anahtarlarınızdan, çünkü verileriniz daha büyük bir veri kümesinde birikmeye başladığında çok daha büyük sorunlar yaratacaktır. Bu, özellikle $ merge gibi toplu işleçleri çağırdığınızda sorunlara neden olur, bu da bir hata atacak anahtarlara erişmeyi ve karşılaştırmayı gerektirir. Zor yoldan öğrendim, lütfen yeni başlayanlar için tekrar etmeyin.

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

Hata mesajlarında buldum. Eğer kullanırsanız anaconda(değilse muhabir dosyayı bulmak), basitçe gelen değerini değiştirmek check_keys = Trueiçin Falseyukarıda belirtilen dosyada. Bu işe yarayacak!