Comment trouver le schéma d'une collection dans MongoDB

MEAN stack est l'une des collections de technologies les plus exigeantes de nos jours. Il comprend MongoDB ExpressJS AngularJS et NodeJS. Mais que vous travailliez sur la pile complète ou sur MongoDB seul, vous voudrez peut-être sauvegarder et restaurer votre base de données. Les données sauvegardées dans MongoDB sont généralement sous la forme de bson / json et peuvent être restaurées à l’aide de commandes facilement disponibles sur la documentation et les plates-formes de MongoDB telles que StackOverflow.

Bien que restaurer et sauvegarder des données dans MongoDB fonctionne comme un charme, vous souhaiterez parfois importer une sauvegarde MongoDB. Et pour continuer à travailler sur les données, vous devez connaître les schémas des collections.

Si vous avez de la chance, vous aurez les fichiers de schéma, mais si vous ne les avez pas, vous pouvez toujours trouver le schéma de la collection en utilisant les données qui y résident. Laisse moi te dire comment.

Nous pouvons obtenir l'objet de schéma / premier document de la collection en utilisant:

var schemaObj = db.users.findOne ();

Maintenant, pour imprimer le schéma, nous pouvons imprimer la clé de chaque propriété de schemaObj et le type de propriété (par exemple, chaîne / nombre, etc.). Pour cela, écrivons une fonction qui prend schemaObj en entrée et affiche les informations requises sur la console.

fonction printSchema (obj) {
        pour (clé var dans obj) {
            print (indent, key, typeof obj [key]);
        }
    };

La fonction ci-dessus imprime le schéma et le résultat est:

C'est super. Droite? Mais il semble que «loginInfo», «paramètres», «rôles» et «méta» soient des objets et peuvent avoir plusieurs sous-propriétés. Nous pourrions aussi vouloir ces informations (c’est-à-dire imprimer des schémas imbriqués). Pour cela, améliorons notre fonction «printSchema» et l’instruction d’appel de fonction comme suit:

fonction printSchema (obj, indent) {
        pour (clé var dans obj) {
            print (indent, key, typeof obj [key]);
            if (typeof obj [clé] == "objet") {
                printSchema (obj [key], indent + "\ t")
            }
        }
    };
printSchema (schemaObj, "");

Le code ci-dessus imprime maintenant la sortie suivante:

Génial! Mais je peux aussi voir les fonctions dans la sortie ci-dessus. Si nous ne le voulons pas, nous pouvons les omettre en modifiant un peu la fonction comme suit:

fonction printSchema (obj, indent) {
    pour (clé var dans obj) {
        if (typeof obj [key]! = "function") {// nous ne voulons pas imprimer de fonctions
           print (indent, key, typeof obj [key], type);
            if (typeof obj [clé] == "objet") {// si la propriété en cours est de type objet, affiche également ses propriétés secondaires
                printSchema (obj [clé], indent + "\ t");
            }
        }
    }
};

Notre fonction printSchema donne maintenant la sortie suivante:

Pour les développeurs avancés: (Puisque c'est amusant: P)

Vous remarquerez peut-être que «_created», «_last_modified» sont des objets. Mais généralement, ce sont en fait des instances d'objet Date. De même, la propriété «roles» semble être un tableau de chaînes. Nous pouvons obtenir le type de données actuel en modifiant davantage notre fonction printSchema comme suit:

fonction printSchema (obj, indent) {
    pour (clé var dans obj) {
        if (typeof obj [key]! = "function") {// nous ne voulons pas imprimer de fonctions
            var SpecificDataTypes = [Date, Array]; // spécifie les types de données spécifiques que vous souhaitez vérifier
            var type = "";
            for (var i in specificDataTypes) {// boucle sur [Date, Array]
                if (obj [clé] instance de SpecificDataTypes [i]) {// si la propriété actuelle est une instance du DataType
                        type = "== is_" + SpecificDataTypes [i] .name + "=="; // obtient son nom
                        Pause;
                }
            }
            print (indent, key, typeof obj [key], type); // imprimer sur la console (par exemple, l'objet de rôles is_Array)
            if (typeof obj [clé] == "objet") {// si la propriété en cours est de type objet, affiche également ses propriétés secondaires
                printSchema (obj [clé], indent + "\ t");
            }
        }
    }
};
printSchema (vue grand angle)

Voici le résultat final pour notre exemple de schéma d'utilisateur:

C'est ici. Vous pouvez extraire avec succès le schéma du document d'une collection dans MongoDB en utilisant la méthode ci-dessus. Et il imprimera la hiérarchie complète du schéma, peu importe l’imbrication du schéma.

Un exemple d'utilisation après extraction du schéma serait le suivant en utilisant Mongoose dans NodeJS:

var userSchema = new mongoose.Schema ({
 loginInfo: {
     providerID: {type: String},
     providerKey: {type: String}
 },
 firstName: {type: String},
 lastName: {type: String},
 nom complet: {type: String},
 email: {type: String},
 mot de passe: {type: String},
 salt: {type: String},
 réglages: {
     preferredLang: {type: String},
     isReceiveNotification: {type: Boolean},
     isReceiveEmail: {type: Boolean},
 },
 rôles: {type: Array},
 statut: {type: String},
 méta: {
     _member: {type: String},
     _version: {type: Number},
     _created_by: {type: String},
     _created: {type: Date},
     _last_modified: {type: Date},
     _owner: {type: String},
     _modified_by: {type: String},
 }
});

Essayer de nouvelles technologies est toujours amusant. Parfois, on entre facilement dans le jeu, mais quand on est coincé dans un problème et qu’on ne trouve pas de solution, croyez-moi, c’est un vrai Douleur. J'aime sérieusement! Bravo à tous pour apporter des solutions aux problèmes les plus fous auxquels nous sommes confrontés au cours du développement.