python - 有没有办法在 mongodb 中获取集合的所有字段名称？

Question

有什么方法可以在 MongoDb 中获取集合的字段（列名）。就像我们在mysql中一样：

SHOW columns FROM table_name

或任何检查集合中是否存在特定字段的方法。

Answer 1

第一个问题不，因为集合中的每个文档都是独立的；第二个问题是（使用$exists）：

# Get the count of docs that contain field 'fieldname'
db.coll.find({'fieldname': {'$exists': 1}}).count()

Answer 2

在 MongoDB 中，每个条目都可以包含不同数量的字段，以及不同的字段名称。这就是为什么 Mongo API 中没有这样的命令的原因：在 MySQL 中，您可以这样做，因为每一行都将具有相同数量的列和相同的列名。在 MongoDB 中，你不能做出这个假设。您可以做的是通过以下方式检查检索到的文档中是否存在字段：

if field_name in doc:
    # Do stuff.

field_name您要检查是否存在的“列”名称在哪里，而 doc 是光标指向的当前名称doc。请记住，这doc是一个 dict，因此您可以像对待 Python 中的任何其他 dict 一样对待它。

Answer 3

这不是最佳实践，但您可以在 shell 中键入

Object.keys(db.posts.findOne())

注意：这不会向您显示对象中的内部键，您可以使用 map reduce 来解决此问题，但如果您的对象很简单，这几乎可以完成任务。

Answer 4

由于每个文档都是相互独立的，因此没有简单的方法可以做到这一点，但是，如果您想了解您的收藏中的内容，您可以使用 Variety，如下所述：

http://blog.mongodb.org/post/21923016898/meet-variety-a-schema-analyzer-for-mongodb

它基本上 Map Reduces 您的集合以找出您在其中的哪些字段。

正如@JohnnyHK 所说，您可以使用以下方法检查字段的存在： http$exists : //docs.mongodb.org/manual/reference/operator/exists/

Answer 5

我在处理一些第三方异构数据时遇到了同样的问题，我在整个集合上使用 map reduce 解决了这个问题，这是我使用的 js 代码，以防你发现它有用：

function MapKeys() {      
var tmp,tmpEmpty,ChildObjTp,ChildIsAr; 
var levelCurrent=0; 
var record=this;
function isArray(obj) {return typeof(obj)=='object'&&(obj instanceof Array);}  
//function emptyIf(obj){if (obj=='tojson')   {return  ' ';} else {return obj+' '}; }  //@note date fields return .tojson so strip it
function emptyIf(obj){if (typeof(this[obj])=='function')   {return  ' ';} else {return obj+' ';} }  //@note date fields return .tojson so strip it
//var toType = function(obj) {      // * http://javascriptweblog.wordpress.com/2011/08/08/fixing-the-javascript-typeof-operator/
//    return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase() 
//  }
function keysToArray(obj,propArr,levelMax, _level) {
    /** example: r1=keysToArray(doc,[null,[] ],2,0) 
        _level is used for recursion and should always called with 0
        if levelMax is negative returns maximum level
        levelMax=0 means top level only 2 up to 2nd depth level etc.
    */ 
        for (var key in obj) { 
            if (obj.hasOwnProperty(key)) { 
                if (obj[key] instanceof Object && ! (obj[key]  instanceof Array))  
                    if (levelMax < 0 || _level+1  <= levelMax) { 
                        {propArr[1].push(keysToArray(obj[key],[key,[] ],levelMax,_level+1));}
                    }
                    else {}  //needed coz nested if ?  
                {propArr[1].push(key);} 
            }
        } 
        return  propArr;
    } 
//----------------------------------------------------------------------------------------------
function arrayToStr(lst,prevKey,delimiter, inclKeys,levelMax,_level,_levelMaxFound) {
    /** example: r2=arrayToStr(r1,'','|',true,2,0,0)
        _level and _levelMaxFound is used for recursion and should always called with value 0
        if levelMax is negative returns maximum level
        levelMax=0 means top level only 2 up to 2nd depth level etc.
    */ 
        var rt,i;
        _levelMaxFound=Math.max(_level,_levelMaxFound);
        if (prevKey !=='') {prevKey += '.';}
        var rtStr ='';  
        if (lst[0])     {prevKey += lst[0]+'.';} 
        if (inclKeys)   {rtStr += prevKey.slice(0,-1);} 
        for (var n in lst[1]) {
            i=lst[1][n];
            if (typeof(i)=='string') {
                rtStr += delimiter + prevKey + i;
            }
            else
            {
                if (levelMax < 0 || _level+1  <= levelMax) {
                    rt=arrayToStr(i,prevKey.slice(0,-1),delimiter, inclKeys,levelMax,_level+1,_levelMaxFound);
                    rtStr += delimiter + rt[0];
                    _levelMaxFound=Math.max(rt[1],_levelMaxFound);
                }
                else {} 
            }
        }
        if (rtStr[0] == delimiter) {rtStr=rtStr.slice(1);}  // Lstrip delimiters if any
        return [rtStr,_levelMaxFound]
    }
//----------------------------------------------------------------------------------------------

var keysV=keysToArray(this,[null,[] ] ,parms.levelMax, 0);   // we can't sort here coz array is nested
keysV = arrayToStr(keysV,'',' ', parms.inclHeaderKeys,-1,0,0); 
var MaxDepth=keysV[1];
keysV=keysV[0].split(' ');  // so we can sort 
keysV.sort();               // sort to make sure indentical records map to same id 
keysV=keysV.join(' ');
emit  ({type:'fieldsGrp',fields:keysV}, {cnt:1, percent:0.0,depth:MaxDepth,exampleIds:[this._id]});}

function ReduceKeys (key, values) { 
//var total = {cnt:0,percent:0.0,exampleIds:[]}  
var total = {cnt:0, percent:0.0,depth:values[0].depth,exampleIds:[]}
for(var i in values) {
    total.cnt += values[i].cnt; 
    if (total.exampleIds.length < parms.Reduce_ExamplesMax){ 
        total.exampleIds = values[i].exampleIds.concat(total.exampleIds);  
        }
    } 
return total;}