मैं एक MongoDB संग्रह में सभी कुंजियों के नाम प्राप्त करना चाहता हूं।
उदाहरण के लिए, इससे:
db.things.insert( { type : ['dog', 'cat'] } );
db.things.insert( { egg : ['cat'] } );
db.things.insert( { type : [] } );
db.things.insert( { hello : [] } );
मैं अद्वितीय कुंजी प्राप्त करना चाहता हूं:
type, egg, helloजवाबों:
आप 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"
})
फिर सभी कुंजियों को खोजने के लिए परिणामी संग्रह पर अलग से दौड़ें:
db[mr.result].distinct("_id")
["foo", "bar", "baz", "_id", ...]
for (var key in this.first_level.second_level.nth_level) { emit(key, null); }
db.runCommand({..., out: { "inline" : 1 }}).results.map(function(i) { return i._id; });
साथ क्रिस्टीना का जवाब : प्रेरणा के रूप में, मैं विभिन्न प्रकार कहा जाता है एक खुला स्रोत उपकरण है जो वास्तव में यह करता बनाई https://github.com/variety/variety
आप नए के साथ एकत्रीकरण का उपयोग कर सकते $objectToArrrayमें 3.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"}}
])
.next()["allkeys"]कमांड को जोड़ सकते हैं (यह मानते हुए कि संग्रह में कम से कम एक तत्व है)।
इसे इस्तेमाल करे:
doc=db.thinks.findOne();
for (key in doc) print(key);
यदि आपका लक्ष्य संग्रह बहुत बड़ा नहीं है, तो आप इसे मानगो शेल क्लाइंट के तहत आज़मा सकते हैं:
var allKeys = {};
db.YOURCOLLECTION.find().forEach(function(doc){Object.keys(doc).forEach(function(key){allKeys[key]=1})});
allKeys;
एक साफ और पुन: प्रयोज्य समाधान pongongo का उपयोग कर:
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', ... ]if (typeof(this[key]) == 'number')पहले उदाहरण के लिए जोड़ें emit(key, null)।
अजगर का उपयोग करना। संग्रह में सभी शीर्ष-स्तरीय कुंजी का सेट लौटाता है:
#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()
)यहाँ पायथन में काम किया गया नमूना है: यह नमूना परिणाम को इनलाइन लौटाता है।
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']यदि आप ३.४.४ और इसके बाद के संस्करण का उपयोग कर रहे हैं तो आप नीचे एकत्रीकरण का उपयोग करके $objectToArrayऔर $groupएकत्रीकरण का उपयोग कर सकते हैं
db.collection.aggregate([
{ "$project": {
"data": { "$objectToArray": "$$ROOT" }
}},
{ "$project": { "data": "$data.k" }},
{ "$unwind": "$data" },
{ "$group": {
"_id": null,
"keys": { "$addToSet": "$data" }
}}
])यहाँ काम करने का उदाहरण है
$matchएकत्रीकरण पाइपलाइन की शुरुआत में भी उपयोग कर सकते हैं केवल उन दस्तावेजों की कुंजी प्राप्त करें जो एक शर्त (एस) से मेल खाते हैं।
मैं आश्चर्यचकित हूं, यहां किसी के पास सरल javascriptऔर Setतर्क का उपयोग करके स्वचालित रूप से डुप्लिकेट मानों को फ़िल्टर करने के लिए नहीं है, नीचे के रूप में मोंगो पर सरल उदाहरण :
var allKeys = new Set()
db.collectionName.find().forEach( function (o) {for (key in o ) allKeys.add(key)})
for(let key of allKeys) print(key)यह संग्रह नाम में सभी संभव अद्वितीय कुंजियों को प्रिंट करेगा : संग्रहनाम ।
मुझे लगता है कि यह सबसे अच्छा तरीका है जैसा कि यहां बताया गया है कि यह 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"}निम्नलिखित पाइपलाइन से सभी कुंजियाँ मिलती हैं (फ़ील्ड 1, फ़ील्ड 2, फ़ील्ड 3, फ़ील्ड 4)।
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 फ़ील्ड्स * no.of डॉक्स) में विस्फोट हो जाएगा, हम $mergeObjectsसभी संस्करणों पर उपयोग करके इससे बच सकते हैं > 3.6.. यही किया था, इससे पहले इस उत्तर को देखा होगा, मेरा जीवन इस तरह से आसान हो गया होगा ( -_-)
हो सकता है कि थोड़ा-सा विषय हो, लेकिन आप किसी ऑब्जेक्ट के सभी कुंजी / फ़ील्ड को पुन: प्रिंट कर सकते हैं:
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)
}उपयोगी जब एक संग्रह में सभी वस्तुओं में एक ही संरचना होती है।
सभी कुंजियों की सूची प्राप्त करने के लिए _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"];मैं नोडज में लिखने की कोशिश कर रहा था और आखिरकार यह आया:
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;
});मोंगोल्डब प्रलेखन के अनुसार , का एक संयोजनdistinct
किसी एकल संग्रह या दृश्य में किसी निर्दिष्ट फ़ील्ड के लिए अलग मानों को ढूँढता है और परिणाम को किसी सरणी में लौटाता है।
और अनुक्रमित संग्रह संचालन वे हैं जो किसी दिए गए कुंजी या सूचकांक के लिए सभी संभावित मूल्यों को लौटाएंगे:
एक सरणी देता है जो दस्तावेजों की एक सूची रखता है जो संग्रह पर मौजूदा अनुक्रमित की पहचान और वर्णन करता है
इसलिए किसी दिए गए तरीके में, कोई भी निम्न की तरह एक विधि का उपयोग कर सकता है, सभी पंजीकृत अनुक्रमितों के लिए एक संग्रह को क्वेरी करने के लिए, और वापस लौटें, कुंजी के लिए अनुक्रमित के साथ एक ऑब्जेक्ट का कहना है (यह उदाहरण NodeJS के लिए async / प्रतीक्षा का उपयोग करता है, लेकिन स्पष्ट रूप से आप किसी अन्य अतुल्यकालिक दृष्टिकोण का उपयोग कर सकते हैं):
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 चालक के लिए मूल तरीकों का उपयोग करता है। जैसा कि कुछ अन्य उत्तरों ने सुझाव दिया है, अन्य दृष्टिकोण हैं, जैसे कि समग्र रूपरेखा। मुझे व्यक्तिगत रूप से यह दृष्टिकोण अधिक लचीला लगता है, क्योंकि आप आसानी से बना सकते हैं और परिणाम को वापस करने के लिए ठीक-ठीक ट्यून कर सकते हैं। जाहिर है, यह केवल शीर्ष-स्तरीय विशेषताओं को संबोधित करता है, न कि नेस्टेड लोगों को। इसके अलावा, यह सुनिश्चित करने के लिए कि सभी दस्तावेजों का प्रतिनिधित्व किया जाता है, माध्यमिक सूचकांक (मुख्य _ एक के अलावा अन्य) होना चाहिए, उन अनुक्रमितों को सेट किया जाना चाहिए required।
हम इसे mongo js फ़ाइल का उपयोग करके प्राप्त कर सकते हैं। नीचे दिए गए कोड को अपने getCollectionName.js फ़ाइल में जोड़ें और 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
@ जेम्स क्रापचो के जवाब से धागे के बाद, मैं निम्नलिखित पर उतरा जो मुझे उपयोग करने के लिए सुपर आसान लगा। यह एक द्विआधारी उपकरण है, जो वास्तव में वही है जो मैं देख रहा था: मोंगोई ।
इस टूल का उपयोग करते हुए मेरे स्कीमा को कमांड लाइन से निर्यात करने में लगभग 2 मिनट का समय लगा।
मुझे पता है कि यह सवाल 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());मैंने कार्लोस एलएम के समाधान को थोड़ा बढ़ाया ताकि यह अधिक विस्तृत हो।
एक स्कीमा का उदाहरण:
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;
}
}
}Daud:
schemafy(db.collection.findOne());उत्पादन
_id <number>
id <number>
t <string>
p <number>
ls <object>:
0 <object>:
l <string>
p <object>:
pp <number> मेरे पास 1 सरल काम है ...
अपने मुख्य संग्रह "चीजों" में डेटा / दस्तावेज़ सम्मिलित करते समय आप क्या कर सकते हैं "आपको 1 अलग संग्रह में विशेषताओं को सम्मिलित करना होगा" बताएं "चीजें"।
इसलिए हर बार जब आप "चीजों" में सम्मिलित होते हैं, तो आप "things_attributes" से प्राप्त करते हैं, उस दस्तावेज़ के मूल्यों की तुलना अपने नए दस्तावेज़ कुंजियों से करते हैं यदि कोई भी नई कुंजी वर्तमान में उस दस्तावेज़ में संलग्न होती है और उसे फिर से सम्मिलित करते हैं।
तो चीजें_अवशेषताओं में केवल 1 अद्वितीय कुंजियों का दस्तावेज होगा, जिसे आप आसानी से तब प्राप्त कर सकते हैं जब आपको कभी भी आवश्यकता होती है findOne () का उपयोग करके।