コレクション内のすべてのキーの名前を取得します


322

MongoDBコレクションのすべてのキーの名前を取得したいのですが。

たとえば、これから:

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

一意のキーを取得したい:

type, egg, hello

回答:


346

あなたは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", ...]

2
こんにちは!データ構造のより深いレベルにあるキーでもこのスニペットを機能させる方法を尋ねるこの質問のフォローアップを投稿しました(stackoverflow.com/questions/2997004/…)。
Andrea Fiore

1
@kristina:モノのコレクションでこれを使用するときに、キーとともにすべてのモノを一覧表示できるのはなぜですか。私が得るので、それは歴史のメカニズムに関連見えるもの、私が過去に変更した...
ショーン

3
これは古いスレッドであることは知っていますが、同様のニーズがあるようです。nodejs mongodbネイティブドライバーを使用しています。結果の一時的なコレクションは常に空のようです。このために、コレクションクラスでmapreduce関数を使用しています。それは不可能ですか?
Deepak

6
このことは、明白であるかもしれませんが、サブドキュメント内のすべてのユニークなキーの一覧を取得したい場合は、ちょうどこの行を変更しますfor (var key in this.first_level.second_level.nth_level) { emit(key, null); }
dtbarne

3
代わりに、その上の個別の実行されている、コレクションに保存するので、私は(マップを使用):db.runCommand({..., out: { "inline" : 1 }}).results.map(function(i) { return i._id; });
イアン・スタンレー


74

あなたは新しいと集約を使用することができます$objectToArrray3.4.4続く文書アレイにすべてのトップ・キー&値のペアを変換するために、バージョン$unwind$group $addToSetコレクション全体を介して別々のキーを取得します。

$$ROOT トップレベルのドキュメントを参照するため。

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

以下のクエリを使用して、単一のドキュメントでキーを取得できます。

db.things.aggregate([
  {"$match":{_id: "5e8f968639bb8c67726686bc"}}, /* Replace with the document's ID */
  {"$project":{"arrayofkeyvalue":{"$objectToArray":"$$ROOT"}}},
  {"$project":{"keys":"$arrayofkeyvalue.k"}}
])

20
これは本当に最良の答えです。他のプログラミング言語やパッケージを使用せずに問題を解決し、集約フレームワークをサポートするすべてのドライバー(Meteorを含む)でも動作します
Micah Henning

2
「allkeys」キーを持つ単一のマップエントリを含むカーソルではなく配列を返す場合は.next()["allkeys"]、コマンドに追加できます(コレクションに少なくとも1つの要素があると想定)。
M.ジャスティン

19

これを試して:

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

49
これは、コレクション内の1つのドキュメントのフィールドのみを出力するため、不正解です。他のフィールドはすべて完全に異なるキーを持つ場合があります。
Asya Kamsky 2014年

15
それは私にとって最も有用な答えであり、単純な合理的な最小値です。
Boris Burkov 14

11
役に立たない?それがあなたに間違った答えを与えた場合、それはどのように役立ちますか?
Zlatko、2015年

4
コンテキストは何が役立つかを示しています。データが正規化されている場合(例:CSVファイルのorigen)、それは役立ちます... SQLからインポートされたデータの場合に役立ちます。
Peter Krauss

5
これは良い答えではありません。コレクション内のすべてのキーではなく、コレクション内の1つの要素のキーを取得する方法に関する答えです。
yonatan 2016年

16

ターゲットコレクションが大きすぎない場合は、mongoシェルクライアントでこれを試すことができます。

var allKeys = {};

db.YOURCOLLECTION.find().forEach(function(doc){Object.keys(doc).forEach(function(key){allKeys[key]=1})});

allKeys;

ここで、私が見たい場合、特定のキーにregExpを与えるにはどうすればよいですか?
TB.M 2017年

@ TB.Mあなたはこれを試すことができます:db.configs.find()。forEach(function(doc){Object.keys(doc).forEach(function(key){if(/YOURREGEXP/.test(key)){ allKeys [key] = 1}})});
Li Chunlin 2017年

ここでテストとはどういう意味ですか?説明してもらえますか?
TB.M 2017年


14

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', ... ]

1
よく働く。最後に、私の問題は解決しました....これは、スタックオーバーフローで最も簡単なソリューションを私鋸は...ある
スマックアルファ

タイプでフィルタリングするには、たとえばif (typeof(this[key]) == 'number')beforeを追加しemit(key, null)ます。
Skippy le Grand Gourou

10

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

1
私はこれが機能することを発見しましたが、生のmongodクエリと比較してどれほど効率的ですか?
ジーザスゴメス

1
これは、Mongodbで直接実行する場合に比べて非常に非効率的であると確信しています
Ingo Fischer

9

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

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

これが実際の例です


これが最良の答えです。$match集計パイプラインの最初に使用して、条件に一致するドキュメントのキーのみを取得することもできます。
RonquilloAeon、

5

驚いたことに、以下のようにmongoシェルの簡単な例である重複した値を自動的にフィルタリングするシンプルjavascriptSetロジックを使用することで、ここに誰もansがいません:

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


3

これは私にとってはうまくいきます:

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);
}

3

ここで述べようにこれを行う最良の方法はmongod 3.4.4以降ですが、$unwind演算子を使用せず、パイプラインで2つのステージのみを使用します。代わりに、$mergeObjectsand $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"
                        }
                    }
                ]
            }
        }
    }
]

少しの努力で、要素もオブジェクトである配列フィールド内のすべてのサブドキュメントのキーを取得できます。


はい、$unwindコレクションを爆発させます(no.of fields * no.of docs)、$mergeObjectsすべてのバージョンで使用することでそれを回避できます> 3.6..同じでした。以前にこの答えを見たことがあるはずですが、私の人生はもっと簡単だったでしょう( -_-)
whoami

3

トピックから少し外れるかもしれませんが、オブジェクトのすべてのキー/フィールドを再帰的にきれいに印刷できます:

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

コレクション内のすべてのオブジェクトが同じ構造を持つ場合に役立ちます。


1

すべてのキーマイナスのリストを取得するに_idは、次の集計パイプラインを実行することを検討してください。

var keys = db.collection.aggregate([
    { "$project": {
       "hashmaps": { "$objectToArray": "$$ROOT" } 
    } }, 
    { "$project": {
       "fields": "$hashmaps.k"
    } },
    { "$group": {
        "_id": null,
        "fields": { "$addToSet": "$fields" }
    } },
    { "$project": {
            "keys": {
                "$setDifference": [
                    {
                        "$reduce": {
                            "input": "$fields",
                            "initialValue": [],
                            "in": { "$setUnion" : ["$$value", "$$this"] }
                        }
                    },
                    ["_id"]
                ]
            }
        }
    }
]).toArray()[0]["keys"];

0

私は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');
        });
 });

新しく作成されたコレクション「allFieldNames」を読み取った後、それを削除します。

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

0

mongoldbのドキュメントによると、の組み合わせdistinct

単一のコレクションまたはビュー全体で指定されたフィールドの個別の値を検索し、結果を配列で返します。

そして、インデックスのコレクション操作は、与えられたキー、またはインデックス可能なすべての値を返すだろうか、次のとおりです。

コレクションの既存のインデックスを識別および説明するドキュメントのリストを保持する配列を返します

したがって、特定のメソッドでは、次のようなメソッドを使用して、コレクションに登録されているすべてのインデックスのコレクションをクエリし、キーのインデックスを持つオブジェクトを返すことができます(この例では、NodeJSにasync / awaitを使用していますが、明らかに、他の非同期アプローチを使用できます):

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インデックスでコレクションをクエリすると、次の結果が返されます(テストコレクションには、テスト時に1つのドキュメントしかありません)。

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ドライバーにネイティブなメソッドを使用しています。他のいくつかの回答が示唆しているように、集約フレームワークなどの他のアプローチがあります。結果を返す方法を簡単に作成して微調整できるので、私は個人的にこのアプローチがより柔軟であると思います。明らかに、これはネストされた属性ではなく、トップレベルの属性のみを扱います。また、(main _id以外の)セカンダリインデックスが存在する場合にすべてのドキュメントが表示されることを保証するには、これらのインデックスをとして設定する必要がありますrequired


0

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


0

@James Cropchoの回答のスレッドに従って、私は次のサイトに行きました。これは非常に使いやすいことがわかりました。これはバイナリツールで、まさに私が探していたものです: mongoeye

このツールを使用すると、コマンドラインからスキーマをエクスポートするのに約2分かかりました。


0

私はこの質問が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());

-1

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> 

3
彼の答えは間違っており、あなたはそれに基づいて構築しました。重要なのは、すべてのドキュメントのすべてのフィールドを出力することです。次のフィールドとは異なるフィールドを持つ最初のドキュメントではありません。
Asya Kamsky 2014年

-3

私は1つの簡単な回避策を持っています...

あなたができることは、メインのコレクション「もの」にデータ/ドキュメントを挿入している間、1つの別個のコレクションに属性を挿入しなければならないことです。

そのため、「things」に挿入するたびに、「things_attributes」から取得し、そのドキュメントの値を新しいドキュメントキーと比較して、新しいキーが存在する場合は、そのドキュメントに追加し、再度挿入します。

つまり、things_attributesには一意のキーのドキュメントが1つだけあり、findOne()を使用して必要なときに簡単に取得できます。


すべてのキーのクエリが頻繁に行われ、挿入が頻繁ではない多くのエントリを持つデータベースの場合、「すべてのキーを取得」クエリの結果をキャッシュすることは意味があります。これはそのための1つの方法です。
スコット
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.