MongoDB point (.) dans le nom de la clé

MongoDB ne prend pas en charge les touches avec un point en eux de sorte que vous allez avoir à traiter votre fichier JSON pour les supprimer et les remplacer avant de l'importer ou vous serez vous-même la mise en place de toutes sortes de problèmes.

Il n'y a pas un standard solution de contournement à ce problème, la meilleure approche est trop dépendant de la spécificité de la situation. Mais je préfère éviter n'importe quelle touche de l'encodeur/décodeur approche, si possible, que vous allez continuer à payer les inconvénients de ce à perpétuité, où un JSON restructurer l'aurait vraisemblablement d'un coût ponctuel.

Comme mentionné dans d'autres réponses MongoDB ne permet pas $ ou . caractères d'une map en raison de restrictions sur les noms de champ. Toutefois, comme mentionné dans Signe De Dollar Opérateur De S'Échapper cette restriction ne vous empêche pas de insertion documents avec ces touches, il juste ne vous empêche de mettre à jour ou de l'interrogation eux.

Le problème de simplement remplacer . avec [dot] ou U+FF0E (comme mentionné ailleurs sur cette page), ce qui arrive lorsque l'utilisateur légitimement veut stocker la clé [dot] ou U+FF0E?

Une approche qui Fantom s afMorphia pilote prend, est d'utiliser les séquences d'échappement unicode similaire à celle de Java, mais bien d'assurer le caractère d'échappement est échappé de la première. En substance, le suivant de la chaîne de remplacement est fait (*):

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

Un revers de remplacement est faite lorsque les map sont par la suite lire de MongoDB.

Ou dans Fantom code:

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

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

La seule fois qu'un utilisateur doit être conscient de ces conversions est lors de la construction de requêtes pour les clés.

Donné, il est courant de stocker dotted.property.names dans les bases de données pour la configuration, je crois que cette approche est préférable de simplement l'interdiction de tous ces map.

(*) afMorphia effectue réellement complet /bon unicode échapper à des règles comme mentionné dans D'échappement Unicode syntaxe de Java mais le décrit la séquence de remplacement fonctionne tout aussi bien.

La dernière version stable (v3.6.1) de la MongoDB prend en charge les points (.) dans les clés ou les noms de champ maintenant.

Les noms de champ peut contenir des points (.) et le dollar ($) caractères maintenant

De la MongoDB docs "le caractère '.' ne doit pas apparaître n'importe où dans le nom de la clé". Il semble que vous aurez à venir avec un schéma de codage ou de faire sans.

Une réponse tardive, mais si vous utilisez du Printemps et de Mongo, le Printemps peut gérer la conversion pour vous avec MappingMongoConverter. C'est la solution par JohnnyHK mais géré par Spring.

@Autowired
private MappingMongoConverter converter;

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

Si votre stockées Json est :

{ "axxxb" : "value" }

Par le Ressort (MongoClient), il sera lu comme suit :

{ "a.b" : "value" }

Pas parfait, mais il fonctionne dans la plupart des situations: remplacer les caractères interdits par quelque chose d'autre. Puisque c'est dans les touches, ces caractères doivent être assez rares.

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

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

et les résultats de noter que les valeurs ne sont pas modifiées:

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

Lodash paires vous permettra de changer

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

en

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

à l'aide de

var newObj = _.pairs(oldObj);

Vous donner mon astuce: Vous pouvez à l'aide de JSON.stringify pour économiser de l'Objet/Tableau contient le nom de la clé a points, ensuite d'analyser la chaîne de l'Objet JSON.analyser à traiter lorsque des données de la base de données

Une autre solution de contournement:
Restructurer votre schéma comme:

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

Remplacer le point(.) ou dollar($) avec d'autres personnages qui ne sera jamais utilisé dans le vrai document. Et de restauration de la dot(.) ou dollar($) lors de la récupération du document. La stratégie n'influencera pas les données que l'utilisateur de lire.

Vous pouvez sélectionner le caractère à partir de tous les personnages.

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

Trouvé dans les messages d'erreur. Si vous utilisez anaconda (trouver le fichier correspondant dans le cas contraire), il suffit de modifier la valeur de check_keys = True à False dans le fichier indiqué ci-dessus. Que ça va marcher!