복붙노트

[MONGODB] 컬렉션에서 모든 키의 이름을 가져옵니다

MONGODB

컬렉션에서 모든 키의 이름을 가져옵니다

나는 MongoDB의 컬렉션 모든 키의 이름을 좀하고 싶습니다.

예를 들어,이에서 :

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

나는 고유 키를 좀하고 싶습니다 :

type, egg, hello

해결법

  1. ==============================

    1.당신은 맵리 듀스와 함께이 작업을 수행 할 수 있습니다 :

    당신은 맵리 듀스와 함께이 작업을 수행 할 수 있습니다 :

    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", ...]
    
  2. ==============================

    2.https://github.com/variety/variety : 영감 크리스티나의 대답과 함께, 나는 정확히 수행 다양한라는 오픈 소스 도구를 개발

    https://github.com/variety/variety : 영감 크리스티나의 대답과 함께, 나는 정확히 수행 다양한라는 오픈 소스 도구를 개발

  3. ==============================

    3.당신은 $ 언 와인드 & $ addToSet와 $ 그룹이 전체 컬렉션에서 개별의 키를 얻기 위해 다음 문서 배열에 모든 상위 키 및 값 쌍을 변환 3.4.4 버전의 새로운 $ objectToArrray와 집계를 사용할 수 있습니다.

    당신은 $ 언 와인드 & $ addToSet와 $ 그룹이 전체 컬렉션에서 개별의 키를 얻기 위해 다음 문서 배열에 모든 상위 키 및 값 쌍을 변환 3.4.4 버전의 새로운 $ objectToArrray와 집계를 사용할 수 있습니다.

    $$ 최고 수준의 문서를 참조하기위한 ROOT.

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

    4.이 시도:

    이 시도:

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

    5.당신의 대상 컬렉션이 너무 크지 않으면, 당신은 몽고 쉘 클라이언트에서이 시도 할 수 있습니다 :

    당신의 대상 컬렉션이 너무 크지 않으면, 당신은 몽고 쉘 클라이언트에서이 시도 할 수 있습니다 :

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

    6.파이썬을 사용. 컬렉션의 모든 최상위 키의 집합을 반환합니다 :

    파이썬을 사용. 컬렉션의 모든 최상위 키의 집합을 반환합니다 :

    #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()
    )
    
  7. ==============================

    7.A는 청소 및 재사용 가능한 솔루션은 pymongo를 사용하여 :

    A는 청소 및 재사용 가능한 솔루션은 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', ... ]
    
  8. ==============================

    8.다음은 파이썬에서 근무 샘플은 다음과 같습니다 이 샘플은 인라인 결과를 반환합니다.

    다음은 파이썬에서 근무 샘플은 다음과 같습니다 이 샘플은 인라인 결과를 반환합니다.

    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. ==============================

    9.위 MongoDB를 3.4.4 등을 사용하는 경우에 당신은 $ objectToArray 및 $ 그룹 집계를 사용하여 집계 아래로 사용할 수 있습니다

    위 MongoDB를 3.4.4 등을 사용하는 경우에 당신은 $ objectToArray 및 $ 그룹 집계를 사용하여 집계 아래로 사용할 수 있습니다

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

    다음은 작업 예입니다

  10. ==============================

    10.나는 놀라운 오전, 아무도 여기에 중복 값 아래 몽고의 shellas에 대한 간단한 예제를 필터링 자동으로 간단한 자바 스크립트와 설정 로직을 사용하여 ANS가 없습니다 :

    나는 놀라운 오전, 아무도 여기에 중복 값 아래 몽고의 shellas에 대한 간단한 예제를 필터링 자동으로 간단한 자바 스크립트와 설정 로직을 사용하여 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 사용합니다.

  11. ==============================

    11.이것은 나를 위해 잘 작동합니다 :

    이것은 나를 위해 잘 작동합니다 :

    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);
    }
    
  12. ==============================

    12.모든 키를 뺀 _id의 목록을 얻으려면, 다음과 같은 집계 파이프 라인을 실행 고려 :

    모든 키를 뺀 _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"];
    
  13. ==============================

    13.나는 mongod에 3.4.4+하지만 $ 언 와인드 연산자를 사용하여 파이프 라인의 두 단계를 사용하지 않고 여기에 언급 한 바와 같이 가장 좋은 방법은 이렇게 생각한다. 대신에 우리는 $ mergeObjects 및 $ objectToArray 연산자를 사용할 수 있습니다.

    나는 mongod에 3.4.4+하지만 $ 언 와인드 연산자를 사용하여 파이프 라인의 두 단계를 사용하지 않고 여기에 언급 한 바와 같이 가장 좋은 방법은 이렇게 생각한다. 대신에 우리는 $ mergeObjects 및 $ objectToArray 연산자를 사용할 수 있습니다.

    는 $ 그룹 단계에서, 우리는 키 / 값 컬렉션에있는 모든 문서를 어디에서 하나의 문서를 반환 $의 mergeObjects 연산자를 사용합니다.

    그리고 우리가 열쇠를 반환 $지도와 $ 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, FIELD2, FIELD3, 입력란 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"
                            }
                        }
                    ]
                }
            }
        }
    ]
    

    약간의 노력으로, 우리는 요소뿐만 아니라 객체입니다 배열 필드의 모든 하위 문서에 대한 키를 얻을 수 있습니다.

  14. ==============================

    14.나는 nodejs에 쓰기를 시도하는 마지막이 함께했다되었다 :

    나는 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; 
    });
    
  15. ==============================

    15.mongoldb 문서, 별개의 조합에 따라

    mongoldb 문서, 별개의 조합에 따라

    인덱스 수집 작업은 주어진 키 또는 인덱스에 대한 모든 가능한 값을 반환 무엇 :

    그래서 모두가 인덱스를 등록하고, 반환 것을위한 컬렉션을 조회하기 위해, 다음과 같은 방법을 사용 할 수있는 특정 방법의 하나로, 키에 대한 인덱스 오브젝트 (사용 비동기 / await를 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의 이외의) 보조 인덱스가 있어야 표현되는 것을 보장에, 그 인덱스를 설정해야합니다.

  16. ==============================

    16.어쩌면 약간 오프 주제,하지만 당신은 재귀 적으로 모든 키를 꽤 - 인쇄 할 수 있습니다 / 객체의 필드를 :

    어쩌면 약간 오프 주제,하지만 당신은 재귀 적으로 모든 키를 꽤 - 인쇄 할 수 있습니다 / 객체의 필드를 :

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

    유용한 컬렉션의 모든 오브젝트는 동일한 구조를 갖는 경우.

  17. ==============================

    17.우리는 몽고의 js 파일을 사용하여이 작업을 수행 할 수 있습니다. 아래에 주어진대로 getCollectionName.js 파일과 리눅스의 콘솔에서 실행 JS 파일의 코드를 아래에 추가 :

    우리는 몽고의 js 파일을 사용하여이 작업을 수행 할 수 있습니다. 아래에 주어진대로 getCollectionName.js 파일과 리눅스의 콘솔에서 실행 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

  18. ==============================

    18.@ 제임스 Cropcho의 대답에서 스레드에 따라, 나는 매우 쉽게 사용할 수있는 다음에 착륙했습니다. 그것은 바로 내가 찾던 무엇 바이너리 도구입니다 : mongoeye.

    @ 제임스 Cropcho의 대답에서 스레드에 따라, 나는 매우 쉽게 사용할 수있는 다음에 착륙했습니다. 그것은 바로 내가 찾던 무엇 바이너리 도구입니다 : mongoeye.

    그것은 2 분 걸렸다이 도구를 사용하면 명령 줄에서 내 보낸 내 스키마를 얻을 수 있습니다.

  19. ==============================

    19.그것이 더 자세히 그래서 나는 조금 카를로스 LM의 솔루션을 확장했다.

    그것이 더 자세히 그래서 나는 조금 카를로스 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> 
    
  20. ==============================

    20.나는 1 간단한 작업 주위가 ...

    나는 1 간단한 작업 주위가 ...

    기본 모음 "일"에 데이터 / 문서를 삽입하는 동안 당신이 할 수있는 것은 당신이 1 개 분리 수거에 속성을 삽입해야합니다은의는 "사물의 속성"가정 해 봅시다.

    그래서 당신은 "일"에 삽입 할 때마다 새로운 키 존재가 문서를 추가 할 경우, 당신은 당신의 새 문서 키를 사용하여 해당 문서의 값을 비교 "things_attributes"에서받을 수 있나요 다시 다시 삽입 그것.

    things_attributes)는 (당신이 findOne를 사용하여 필요 어느 때 쉽게 얻을 수있는 고유 키의 1 문서를해야합니다 그래서

  21. from https://stackoverflow.com/questions/2298870/get-names-of-all-keys-in-the-collection by cc-by-sa and MIT license