MongoDB-Punkt (.) Im Schlüsselnamen

Es scheint, dass Mongo das Einfügen von Schlüsseln mit einem Punkt (.) Oder einem Dollarzeichen ($) nicht zulässt. Als ich jedoch eine JSON-Datei importierte, die einen Punkt enthielt, funktionierte dies mit dem Mongoimport-Tool einwandfrei. Der Treiber beschwert sich über den Versuch, dieses Element einzufügen.

So sieht das Dokument in der Datenbank aus:

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

Mache ich das alles falsch und sollte solche Hash-Maps nicht mit externen Daten (dh den Modellen) verwenden oder kann ich dem Punkt irgendwie entkommen? Vielleicht denke ich zu viel Javascript-ähnlich.

MongoDB unterstützt keine Schlüssel mit einem Punkt darin, daher müssen Sie Ihre JSON-Datei vorverarbeiten, um sie vor dem Import zu entfernen / ersetzen, oder Sie müssen sich auf alle möglichen Probleme einstellen.

Es gibt keine Standardumgehung für dieses Problem. Der beste Ansatz hängt zu stark von den Besonderheiten der Situation ab. Ich würde jedoch nach Möglichkeit jeden Key-Encoder / Decoder-Ansatz vermeiden, da Sie die Unannehmlichkeiten weiterhin auf Dauer bezahlen werden, wenn eine JSON-Umstrukturierung vermutlich einmalige Kosten verursachen würde.

Wie in anderen Antworten erwähnt MongoDB nicht erlaubt $oder .Zeichen als Mapkeys wegen Beschränkungen für Feldnamen . Wie in Dollar Sign Operator erwähnt. Wenn Sie dieser Einschränkung jedoch entkommen, können Sie keine Dokumente mit solchen Schlüsseln einfügen , sondern sie nur aktualisieren oder abfragen.

Das Problem beim einfachen Ersetzen .durch [dot]oder U+FF0E(wie an anderer Stelle auf dieser Seite erwähnt) ist, was passiert, wenn der Benutzer den Schlüssel rechtmäßig speichern möchte [dot]oder U+FF0E?

Ein Ansatz, den der afMorphia-Treiber von Fantom verfolgt , besteht darin, Unicode-Escape-Sequenzen zu verwenden, die denen von Java ähnlich sind, aber sicherzustellen, dass das Escape-Zeichen zuerst maskiert wird. Im Wesentlichen werden die folgenden Zeichenfolgen ersetzt (*):

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

Ein umgekehrter Austausch erfolgt, wenn die Kartenschlüssel anschließend aus MongoDB gelesen werden .

Oder im Fantomcode :

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

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

Ein Benutzer muss sich solcher Konvertierungen nur bewusst sein, wenn er Abfragen für solche Schlüssel erstellt.

Da es üblich ist, zu dotted.property.namesKonfigurationszwecken in Datenbanken zu speichern , ist dieser Ansatz meines Erachtens dem einfachen Verbot aller dieser Kartenschlüssel vorzuziehen.

(*) afMorphia führt tatsächlich vollständige / ordnungsgemäße Unicode-Escape- Regeln aus, wie in der Unicode-Escape-Syntax in Java erwähnt, aber die beschriebene Ersetzungssequenz funktioniert genauso gut.

In den Mongo-Dokumenten wird vorgeschlagen , illegale Zeichen wie $und .durch ihre Unicode-Entsprechungen zu ersetzen .

In diesen Situationen müssen die Schlüssel die reservierten $ und ersetzen. Zeichen. Jedes Zeichen ist ausreichend, aber verwenden Sie die Unicode-Äquivalente in voller Breite: U + FF04 (dh „＄“) und U + FF0E (dh „．“).

Die neueste stabile Version (v3.6.1) der MongoDB unterstützt jetzt Punkte (.) In den Schlüsseln oder Feldnamen.

Feldnamen können jetzt Punkte (.) Und Dollarzeichen ($) enthalten

Eine Lösung, mit der ich gerade zufrieden bin, besteht darin, den Schlüsselnamen und den Wert in zwei separate Felder aufzuteilen. Auf diese Weise kann ich die Charaktere exakt gleich halten und mir keine Sorgen über diese Alpträume machen. Das Dokument würde folgendermaßen aussehen:

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

Sie können dies immer noch einfach genug abfragen, indem Sie findin den Feldern keyName und keyValue einen Wert eingeben .

Also statt:

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

was nicht wirklich wie erwartet funktionieren würde, würden Sie ausführen:

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

und es wird das erwartete Dokument zurückgeben.

Sie können versuchen, anstelle des Werts einen Hash im Schlüssel zu verwenden und diesen Wert dann im JSON-Wert zu speichern.

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

Sie würden dann später mit dem Hash auf die Modelle zugreifen.

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

Es wird jetzt unterstützt

Ab MongoDb 3.6 werden sowohl Punkte als auch Dollar in Feldnamen unterstützt. Siehe unten JIRA: https://jira.mongodb.org/browse/JAVA-2810

Ein Upgrade Ihres Mongodb auf 3.6+ klingt nach dem besten Weg.

Aus den MongoDB-Dokumenten "the '." Zeichen darf nirgendwo im Schlüsselnamen erscheinen ". Es sieht so aus, als müssten Sie sich ein Kodierungsschema einfallen lassen oder darauf verzichten.

Sie müssen den Schlüsseln entkommen. Da es den Anschein hat, dass die meisten Menschen nicht wissen, wie sie Strings richtig entkommen können, sind hier die Schritte:

1. Wählen Sie einen Escape-Charakter (am besten einen Charakter, der selten verwendet wird). Z.B. '~'
2. Um zu entkommen, ersetzen Sie zuerst alle Instanzen des Escape-Zeichens durch eine Sequenz, der Ihr Escape-Zeichen vorangestellt ist (z. B. '~' -> '~ t'), und ersetzen Sie dann das Zeichen oder die Sequenz, die Sie zum Escape benötigen, durch eine Sequenz, der Ihr Escape-Zeichen vorangestellt ist . Z.B. '.' -> '~ p'
3. Um zu entkommen, entfernen Sie zuerst die Escape-Sequenz aus allen Instanzen Ihrer zweiten Escape-Sequenz (z. B. '~ p' -> '.') Und transformieren Sie dann Ihre Escape-Zeichenfolge in ein einzelnes Escape-Zeichen (z. B. '~ s' -> '~ ')

Denken Sie auch daran, dass Mongo auch nicht zulässt, dass Schlüssel mit '$' beginnen, sodass Sie dort etwas Ähnliches tun müssen

Hier ist ein Code, der das macht:

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

Eine späte Antwort, aber wenn Sie Spring und Mongo verwenden, kann Spring die Konvertierung für Sie verwalten MappingMongoConverter. Es ist die Lösung von JohnnyHK, wird aber von Spring gehandhabt.

@Autowired
private MappingMongoConverter converter;

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

Wenn Ihr gespeicherter Json ist:

{ "axxxb" : "value" }

Durch den Frühling (MongoClient) wird es gelesen als:

{ "a.b" : "value" }

Ich verwende das folgende Escapezeichen in JavaScript für jeden Objektschlüssel:

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

Was ich daran mag, ist, dass es nur $am Anfang ersetzt wird und keine Unicode-Zeichen verwendet, deren Verwendung in der Konsole schwierig sein kann. _ist für mich viel lesbarer als ein Unicode-Zeichen. Es ersetzt auch nicht einen Satz von Sonderzeichen ( $, .) durch einen anderen (Unicode). Aber richtig entkommt mit traditionellen \.

Nicht perfekt, funktioniert aber in den meisten Situationen: Ersetzen Sie die verbotenen Zeichen durch etwas anderes. Da es sich um Schlüssel handelt, sollten diese neuen Zeichen ziemlich selten sein.

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

Hier ist ein 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) )

und die Ergebnisse - beachten Sie, dass die Werte nicht geändert werden:

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

Es gibt eine hässliche Möglichkeit, es abzufragen. Es wird nicht empfohlen, es in der Anwendung und nicht für Debug-Zwecke zu verwenden (funktioniert nur bei eingebetteten Objekten):

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

Wie bereits von einem anderen Benutzer erwähnt, kann das Codieren / Decodieren in Zukunft problematisch werden. Daher ist es wahrscheinlich einfacher, alle Schlüssel mit einem Punkt zu ersetzen. Hier ist eine rekursive Funktion, die ich gemacht habe, um Schlüssel durch '.' Zu ersetzen. Vorkommen:

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)

Sie können diesen Code ändern, um auch '$' zu ersetzen, da dies ein weiteres Zeichen ist, das Mongo in einem Schlüssel nicht zulässt.

Für PHP ersetze ich den HTML-Wert für den Zeitraum. Das ist"." .

Es speichert in MongoDB wie folgt:

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

und der PHP-Code ...

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

Mit Lodash-Paaren können Sie Änderungen vornehmen

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

in

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

mit

var newObj = _.pairs(oldObj);

Sie können es so speichern, wie es ist, und danach in hübsch konvertieren

Ich habe dieses Beispiel auf Livescript geschrieben. Sie können die Website livingcript.net verwenden, um sie zu bewerten

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

Es wird produzieren

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

Geben Sie meinen Tipp: Sie können JSON.stringify zum Speichern von Object / Array verwenden, das den Schlüsselnamen enthält, der Punkte enthält, und dann die Zeichenfolge mit JSON.parse in Object analysieren, um sie beim Abrufen von Daten aus der Datenbank zu verarbeiten

Eine weitere Problemumgehung: Restrukturieren Sie Ihr Schema wie folgt:

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

Die neueste MongoDB unterstützt Schlüssel mit einem Punkt, der Java MongoDB-Treiber wird jedoch nicht unterstützt. Damit es in Java funktioniert, habe ich Code aus dem Github-Repo des Java-Mongo-Treibers abgerufen und entsprechende Änderungen an der Funktion isValid Key vorgenommen. Daraus wurde ein neues JAR erstellt, das jetzt verwendet wird.

Ersetzen Sie den Punkt ( .) oder den Dollar ( $) durch andere Zeichen, die im realen Dokument niemals verwendet werden. Stellen Sie beim Abrufen des Dokuments den Punkt ( .) oder den Dollar ( $) wieder her. Die Strategie hat keinen Einfluss auf die vom Benutzer gelesenen Daten.

Sie können das Zeichen aus allen Zeichen auswählen .

Das Seltsame ist, dass ich mit Mongojs ein Dokument mit einem Punkt erstellen kann, wenn ich die _id selbst setze. Ich kann jedoch kein Dokument erstellen, wenn die _id generiert wird:

Funktioniert:

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

Funktioniert nicht:

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

Ich dachte zuerst, dass das Aktualisieren eines Dokuments mit einem Punktschlüssel auch funktioniert, aber es identifiziert den Punkt als Unterschlüssel!

Wenn ich sehe, wie Mongojs mit dem Punkt (Unterschlüssel) umgehen, werde ich sicherstellen, dass meine Schlüssel keinen Punkt enthalten.

Entfernen Sie wie das, was @JohnnyHK erwähnt hat, Satzzeichen oder '.' von Ihren Schlüsseln, weil es viel größere Probleme verursacht, wenn sich Ihre Daten in einem größeren Datensatz ansammeln. Dies führt zu Problemen, insbesondere wenn Sie Aggregatoperatoren wie $ merge aufrufen, bei denen auf Schlüssel zugegriffen und diese verglichen werden müssen, wodurch ein Fehler ausgelöst wird. Ich habe es auf die harte Tour gelernt, bitte nicht wiederholen für diejenigen, die anfangen.

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

Fand es in Fehlermeldungen. Wenn Sie verwenden anaconda(suchen Sie die entsprechende Datei, falls nicht), ändern Sie einfach den Wert von check_keys = Truein Falsein der oben angegebenen Datei. Das wird funktionieren!