Question

我想获取MongoDB集合中所有密钥的名称。

例如，从中：

db.things.insert( { type : ['dog', 'cat'] } );
db.things.insert( { egg : ['cat'] } );
db.things.insert( { type : [] } );
db.things.insert( { hello : []  } );

我想获得独特的密钥：

type, egg, hello

Answer 1

您可以使用MapReduce执行此操作：

mr = db.runCommand({
  "mapreduce" : "my_collection",
  "map" : function() {
    for (var key in this) { emit(key, null); }
  },
  "reduce" : function(key, stuff) { return null; }, 
  "out": "my_collection" + "_keys"
})

然后在生成的集合上运行distinct，以便找到所有键：

db[mr.result].distinct("_id")
["foo", "bar", "baz", "_id", ...]

Answer 2

以Kristina's answer作为灵感，我创建了一个名为Variety的开源工具，它完全按照以下方式执行：https://github.com/variety/variety

Answer 3

您可以使用$objectToArrray版本中的新3.4.4汇总来转换所有顶级密钥和＆amp;值对文档数组后跟$unwind＆amp; $group $addToSet $$ROOT可以在整个集合中获得不同的密钥。

{{3}}用于引用顶级文档。

db.things.aggregate([
  {"$project":{"arrayofkeyvalue":{"$objectToArray":"$$ROOT"}}},
  {"$unwind":"$arrayofkeyvalue"},
  {"$group":{"_id":null,"allkeys":{"$addToSet":"$arrayofkeyvalue.k"}}}
])

您可以使用以下查询在单个文档中获取密钥。

db.things.aggregate([
  {"$project":{"arrayofkeyvalue":{"$objectToArray":"$$ROOT"}}},
  {"$project":{"keys":"$arrayofkeyvalue.k"}}
])

Answer 4

试试这个：

doc=db.thinks.findOne();
for (key in doc) print(key);

Answer 5

如果您的目标集合不是太大，可以在mongo shell客户端下尝试：

Option Explicit

Sub AddSetupChart()

Dim ChtObj  As ChartObject
Dim x As Long, y As Long

' set initial size and position of the chart object, will modify them later in the code
Set ChtObj = Worksheets("Sheet1").ChartObjects.Add(Left:=100, Top:=100, _
                                    Width:=100, Height:=100)

' setting some values for the parameters >> just for the example
x = 200
y = 400

With ChtObj
    .Left = x  ' <-- you can use .Left = rgExp.Left 
    .Top = y  ' <-- you can use .Top= rgExp.Top

    ' set the source data of the chart object
    .Chart.SetSourceData (Worksheets("Sheet1").Range("B3:D5"))

    .Chart.ChartType = xlBarStacked  ' define the type of the chart
    .Chart.HasTitle = True  ' add title to the chart
    .Chart.ChartTitle.Text = "Chart Test"  ' modity the title

    ' other properties you want to modify

End With

End Sub

Answer 6

使用python。返回集合中所有顶级键的集合：

#Using pymongo and connection named 'db'

reduce(
    lambda all_keys, rec_keys: all_keys | set(rec_keys), 
    map(lambda d: d.keys(), db.things.find()), 
    set()
)

Answer 7

以下是Python中使用的示例：此示例以内联方式返回结果。

from pymongo import MongoClient
from bson.code import Code

mapper = Code("""
    function() {
                  for (var key in this) { emit(key, null); }
               }
""")
reducer = Code("""
    function(key, stuff) { return null; }
""")

distinctThingFields = db.things.map_reduce(mapper, reducer
    , out = {'inline' : 1}
    , full_response = True)
## do something with distinctThingFields['results']

Answer 8

使用pymongo清理并制作可重复使用的解决方案：

from pymongo import MongoClient
from bson import Code

def get_keys(db, collection):
    client = MongoClient()
    db = client[db]
    map = Code("function() { for (var key in this) { emit(key, null); } }")
    reduce = Code("function(key, stuff) { return null; }")
    result = db[collection].map_reduce(map, reduce, "myresults")
    return result.distinct('_id')

用法：

get_keys('dbname', 'collection')
>> ['key1', 'key2', ... ]

Answer 9

如果您使用的是mongodb 3.4.4及更高版本，则可以使用$objectToArray和$group聚合使用下面的聚合

db.collection.aggregate([
  { "$project": {
    "data": { "$objectToArray": "$$ROOT" }
  }},
  { "$project": { "data": "$data.k" }},
  { "$unwind": "$data" },
  { "$group": {
    "_id": null,
    "keys": { "$addToSet": "$data" }
  }}
])

这是工作中的example

Answer 10

这对我来说很好用：

var arrayOfFieldNames = [];

var items = db.NAMECOLLECTION.find();

while(items.hasNext()) {
  var item = items.next();
  for(var index in item) {
    arrayOfFieldNames[index] = index;
   }
}

for (var index in arrayOfFieldNames) {
  print(index);
}

Answer 11

我认为最好的方法是如上所述here在mongod 3.4.4+中，但不使用$unwind运算符并且只使用管道中的两个阶段。相反，我们可以使用$mergeObjects和$objectToArray运算符。

在$group阶段，我们使用$mergeObjects运算符返回单个文档，其中键/值来自集合中的所有文档。

然后是$project我们使用$map和$objectToArray来返回密钥。

let allTopLevelKeys =  [
    {
        "$group": {
            "_id": null,
            "array": {
                "$mergeObjects": "$$ROOT"
            }
        }
    },
    {
        "$project": {
            "keys": {
                "$map": {
                    "input": { "$objectToArray": "$array" },
                    "in": "$$this.k"
                }
            }
        }
    }
];

现在，如果我们有一个嵌套文档并且想要获取密钥，那么这是可行的。为简单起见，让我们考虑一个带有简单嵌入式文档的文档，如下所示：

{field1: {field2: "abc"}, field3: "def"}
{field1: {field3: "abc"}, field4: "def"}

以下管道产生所有键（field1，field2，field3，field4）。

let allFistSecondLevelKeys = [
    {
        "$group": {
            "_id": null,
            "array": {
                "$mergeObjects": "$$ROOT"
            }
        }
    },
    {
        "$project": {
            "keys": {
                "$setUnion": [
                    {
                        "$map": {
                            "input": {
                                "$reduce": {
                                    "input": {
                                        "$map": {
                                            "input": {
                                                "$objectToArray": "$array"
                                            },
                                            "in": {
                                                "$cond": [
                                                    {
                                                        "$eq": [
                                                            {
                                                                "$type": "$$this.v"
                                                            },
                                                            "object"
                                                        ]
                                                    },
                                                    {
                                                        "$objectToArray": "$$this.v"
                                                    },
                                                    [
                                                        "$$this"
                                                    ]
                                                ]
                                            }
                                        }
                                    },
                                    "initialValue": [

                                    ],
                                    "in": {
                                        "$concatArrays": [
                                            "$$this",
                                            "$$value"
                                        ]
                                    }
                                }
                            },
                            "in": "$$this.k"
                        }
                    }
                ]
            }
        }
    }
]

只需稍加努力，我们就可以获得数组字段中所有子文档的键，其中元素也是对象。

Answer 12

令人惊讶的是，这里没有人使用简单的javascript和Set逻辑自动过滤重复值，这在 mongo shell 上的简单示例如下：< / p>

var allKeys = new Set()
db.collectionName.find().forEach( function (o) {for (key in o ) allKeys.add(key)})
for(let key of allKeys) print(key)

这将在集合名称： collectionName 中打印所有可能的唯一键。

Answer 13

基于@Wolkenarchitekt 答案：https://stackoverflow.com/a/48117846/8808983，我编写了一个脚本，可以在数据库中的所有键中找到模式，我认为它可以帮助其他人阅读此线程：

"""
Python 3
This script get list of patterns and print the collections that contains fields with this patterns.
"""

import argparse

import pymongo
from bson import Code


# initialize mongo connection:
def get_db():
    client = pymongo.MongoClient("172.17.0.2")
    db = client["Data"]
    return db


def get_commandline_options():
    description = "To run use: python db_fields_pattern_finder.py -p <list_of_patterns>"
    parser = argparse.ArgumentParser(description=description)
    parser.add_argument('-p', '--patterns', nargs="+", help='List of patterns to look for in the db.', required=True)
    return parser.parse_args()


def report_matching_fields(relevant_fields_by_collection):
    print("Matches:")

    for collection_name in relevant_fields_by_collection:
        if relevant_fields_by_collection[collection_name]:
            print(f"{collection_name}: {relevant_fields_by_collection[collection_name]}")

    # pprint(relevant_fields_by_collection)


def get_collections_names(db):
    """
    :param pymongo.database.Database db:
    :return list: collections names
    """
    return db.list_collection_names()


def get_keys(db, collection):
    """
    See: https://stackoverflow.com/a/48117846/8808983
    :param db:
    :param collection:
    :return:
    """
    map = Code("function() { for (var key in this) { emit(key, null); } }")
    reduce = Code("function(key, stuff) { return null; }")
    result = db[collection].map_reduce(map, reduce, "myresults")
    return result.distinct('_id')


def get_fields(db, collection_names):
    fields_by_collections = {}
    for collection_name in collection_names:
        fields_by_collections[collection_name] = get_keys(db, collection_name)
    return fields_by_collections


def get_matches_fields(fields_by_collections, patterns):
    relevant_fields_by_collection = {}
    for collection_name in fields_by_collections:
        relevant_fields = [field for field in fields_by_collections[collection_name] if
                           [pattern for pattern in patterns if
                            pattern in field]]
        relevant_fields_by_collection[collection_name] = relevant_fields

    return relevant_fields_by_collection


def main(patterns):
    """
    :param list patterns: List of strings to look for in the db.
    """
    db = get_db()

    collection_names = get_collections_names(db)
    fields_by_collections = get_fields(db, collection_names)
    relevant_fields_by_collection = get_matches_fields(fields_by_collections, patterns)

    report_matching_fields(relevant_fields_by_collection)


if __name__ == '__main__':
    args = get_commandline_options()
    main(args.patterns)

Answer 14

我知道这个问题已有10年历史了，但是没有C＃解决方案，这花了我几个小时才弄清楚。我正在使用.NET驱动程序和System.Linq返回密钥列表。

var map = new BsonJavaScript("function() { for (var key in this) { emit(key, null); } }");
var reduce = new BsonJavaScript("function(key, stuff) { return null; }");
var options = new MapReduceOptions<BsonDocument, BsonDocument>();
var result = await collection.MapReduceAsync(map, reduce, options);
var list = result.ToEnumerable().Select(item => item["_id"].ToString());

Answer 15

根据@James Cropcho的回答，我进入了以下内容，发现它们非常易于使用。这是一个二进制工具，正是我想要的： mongoeye。

使用此工具大约需要2分钟才能从命令行导出我的架构。

Answer 16

我们可以通过使用mongo js文件来实现。在您的 getCollectionName.js 文件中添加以下代码，并在Linux的控制台中运行js文件，如下所示：

mongo --host 192.168.1.135 getCollectionName.js

db_set = connect("192.168.1.135:27017/database_set_name"); // for Local testing
// db_set.auth("username_of_db", "password_of_db"); // if required

db_set.getMongo().setSlaveOk();

var collectionArray = db_set.getCollectionNames();

collectionArray.forEach(function(collectionName){

    if ( collectionName == 'system.indexes' || collectionName == 'system.profile' || collectionName == 'system.users' ) {
        return;
    }

    print("\nCollection Name = "+collectionName);
    print("All Fields :\n");

    var arrayOfFieldNames = []; 
    var items = db_set[collectionName].find();
    // var items = db_set[collectionName].find().sort({'_id':-1}).limit(100); // if you want fast & scan only last 100 records of each collection
    while(items.hasNext()) {
        var item = items.next(); 
        for(var index in item) {
            arrayOfFieldNames[index] = index;
        }
    }
    for (var index in arrayOfFieldNames) {
        print(index);
    }

});

quit();

感谢@ackuser

Answer 17

也许有点偏离主题，但是您可以递归地漂亮打印对象的所有键/字段：

function _printFields(item, level) {
    if ((typeof item) != "object") {
        return
    }
    for (var index in item) {
        print(" ".repeat(level * 4) + index)
        if ((typeof item[index]) == "object") {
            _printFields(item[index], level + 1)
        }
    }
}

function printFields(item) {
    _printFields(item, 0)
}

当集合中的所有对象具有相同的结构时很有用。

Answer 18

根据mongoldb documentation，distinct

的组合

在单个集合或视图中查找指定字段的不同值，并以数组形式返回结果。

和indexes集合操作将返回给定键或索引的所有可能值：

返回一个数组，其中包含用于标识和描述集合
上现有索引的文档列表

因此，在给定的方法中，可以使用类似下面的方法，以便查询集合中所有已注册的索引，并返回，例如带有键索引的对象（此示例使用async / await for NodeJS，但显然你可以使用任何其他异步方法）：

async function GetFor(collection, index) {

    let currentIndexes;
    let indexNames = [];
    let final = {};
    let vals = [];

    try {
        currentIndexes = await collection.indexes();
        await ParseIndexes();
        //Check if a specific index was queried, otherwise, iterate for all existing indexes
        if (index && typeof index === "string") return await ParseFor(index, indexNames);
        await ParseDoc(indexNames);
        await Promise.all(vals);
        return final;
    } catch (e) {
        throw e;
    }

    function ParseIndexes() {
        return new Promise(function (result) {
            let err;
            for (let ind in currentIndexes) {
                let index = currentIndexes[ind];
                if (!index) {
                    err = "No Key For Index "+index; break;
                }
                let Name = Object.keys(index.key);
                if (Name.length === 0) {
                    err = "No Name For Index"; break;
                }
                indexNames.push(Name[0]);
            }
            return result(err ? Promise.reject(err) : Promise.resolve());
        })
    }

    async function ParseFor(index, inDoc) {
        if (inDoc.indexOf(index) === -1) throw "No Such Index In Collection";
        try {
            await DistinctFor(index);
            return final;
        } catch (e) {
            throw e
        }
    }
    function ParseDoc(doc) {
        return new Promise(function (result) {
            let err;
            for (let index in doc) {
                let key = doc[index];
                if (!key) {
                    err = "No Key For Index "+index; break;
                }
                vals.push(new Promise(function (pushed) {
                    DistinctFor(key)
                        .then(pushed)
                        .catch(function (err) {
                            return pushed(Promise.resolve());
                        })
                }))
            }
            return result(err ? Promise.reject(err) : Promise.resolve());
        })
    }

    async function DistinctFor(key) {
        if (!key) throw "Key Is Undefined";
        try {
            final[key] = await collection.distinct(key);
        } catch (e) {
            final[key] = 'failed';
            throw e;
        }
    }
}

因此，使用基本_id索引查询集合将返回以下内容（测试集合在测试时只有一个文档）：

Mongo.MongoClient.connect(url, function (err, client) {
    assert.equal(null, err);

    let collection = client.db('my db').collection('the targeted collection');

    GetFor(collection, '_id')
        .then(function () {
            //returns
            // { _id: [ 5ae901e77e322342de1fb701 ] }
        })
        .catch(function (err) {
            //manage your error..
        })
});

请注意，这使用了NodeJS驱动程序的原生方法。正如其他一些答案所暗示的那样，还有其他方法，例如聚合框架。我个人认为这种方法更灵活，因为您可以轻松创建和微调如何返回结果。显然，这只能解决顶级属性，而不是嵌套属性。此外，为了保证所有文档都被表示，如果存在二级索引（主_id除外），则应将这些索引设置为required。

Answer 19

我试图在nodejs中写，最后提出了这个：

db.collection('collectionName').mapReduce(
function() {
    for (var key in this) {
        emit(key, null);
    }
},
function(key, stuff) {
    return null;
}, {
    "out": "allFieldNames"
},
function(err, results) {
    var fields = db.collection('allFieldNames').distinct('_id');
    fields
        .then(function(data) {
            var finalData = {
                "status": "success",
                "fields": data
            };
            res.send(finalData);
            delteCollection(db, 'allFieldNames');
        })
        .catch(function(err) {
            res.send(err);
            delteCollection(db, 'allFieldNames');
        });
 });

在阅读新创建的集合＆＃34; allFieldNames＆＃34;后，将其删除。

db.collection("allFieldNames").remove({}, function (err,result) {
     db.close();
     return; 
});

Answer 20

我对Carlos LM的解决方案进行了一些扩展，因此它更加详细。

架构示例：

var schema = {
    _id: 123,
    id: 12,
    t: 'title',
    p: 4.5,
    ls: [{
            l: 'lemma',
            p: {
                pp: 8.9
            }
        },
         {
            l: 'lemma2',
            p: {
               pp: 8.3
           }
        }
    ]
};

输入控制台：

var schemafy = function(schema, i, limit) {
    var i = (typeof i !== 'undefined') ? i : 1;
    var limit = (typeof limit !== 'undefined') ? limit : false;
    var type = '';
    var array = false;

    for (key in schema) {
        type = typeof schema[key];
        array = (schema[key] instanceof Array) ? true : false;

        if (type === 'object') {
            print(Array(i).join('    ') + key+' <'+((array) ? 'array' : type)+'>:');
            schemafy(schema[key], i+1, array);
        } else {
            print(Array(i).join('    ') + key+' <'+type+'>');
        }

        if (limit) {
            break;
        }
    }
}

执行命令

schemafy(db.collection.findOne());

输出

_id <number>
id <number>
t <string>
p <number>
ls <object>:
    0 <object>:
    l <string>
    p <object>:
        pp <number>

Answer 21

我有一个更简单的工作......

您可以做的是在将数据/文档插入主集合“事物”时，您必须在1个单独的集合中插入属性，让我们说“things_attributes”。

因此，每当您插入“things”时，您都会从“things_attributes”获得该文档的值与新文档密钥的比较，如果有任何新密钥将其附加到该文档中并再次重新插入它。

因此，thing_attributes将只有1个唯一键文档，您可以通过使用findOne（）

在需要时轻松获取这些文档。

获取集合中所有键的名称

21 个答案: