MongoDB
 sql >> Base de Dados >  >> NoSQL >> MongoDB

4 maneiras de listar as coleções em um banco de dados MongoDB


Ao usar o MongoDB, há mais de uma maneira de listar as coleções em um banco de dados.

Aqui estão quatro maneiras de obter uma lista de coleções em um banco de dados MongoDB:
  • As show collections Comando
  • As listCollections Comando
  • Os db.getCollectionNames() Método
  • O db.getCollectionInfos() Método

As show collections Comando


Se você estiver usando o shell mongo, a maneira mais rápida de obter uma lista de coleções é usar o show collections comando. Este comando recupera uma lista de coleções e exibições no banco de dados atual.

Exemplo:
show collections

Resultado:
 employees
 pets
 pettypes
 products
 system.views 

Neste caso, há cinco resultados. Não podemos dizer apenas olhando, mas pettypes é na verdade uma visão. Os outros são coleções.

O system.views coleção é uma coleção do sistema que contém informações sobre cada exibição no banco de dados.

As coleções reais retornadas dependerão do seu nível de acesso:
  • Para usuários com o acesso necessário, show collections lista as coleções que não são do sistema para o banco de dados.
  • Para usuários sem o acesso necessário, show collections lista apenas as coleções para as quais os usuários têm privilégios.

As listCollections Comando


As listCollections O comando administrativo retorna o nome e as opções de coleções e visualizações no banco de dados. Ele retorna as informações na forma de um documento.

Exemplo:
db.runCommand( { listCollections: 1.0, authorizedCollections: true, nameOnly: true } )

Resultado:
{
    "cursor" : {
        "id" : NumberLong(0),
        "ns" : "PetHotel.$cmd.listCollections",
        "firstBatch" : [
            {
                "name" : "employees",
                "type" : "collection"
            },
            {
                "name" : "system.views",
                "type" : "collection"
            },
            {
                "name" : "pets",
                "type" : "collection"
            },
            {
                "name" : "products",
                "type" : "collection"
            },
            {
                "name" : "pettypes",
                "type" : "view"
            }
        ]
    },
    "ok" : 1
}

O documento contém informações com as quais criar um cursor para as informações da coleção.

Desta vez podemos ver quais são coleções e quais são visualizações.

Também podemos executar o comando assim:
db.runCommand( { listCollections: 1.0 } )

Isso fornece muito mais informações sobre as coleções. Veja o db.getCollectionInfos() exemplo abaixo para ver os dados retornados ao executá-lo assim (o db.getCollectionInfos() método é um wrapper em torno de listCollections ).

O db.getCollectionNames() Método


O db.getCollectionNames() O método retorna um array contendo os nomes de todas as coleções e visualizações no banco de dados atual, ou se estiver executando com controle de acesso, os nomes das coleções de acordo com o privilégio do usuário.

Exemplo:
db.getCollectionNames()

Resultado:
 [ "employees", "pets", "pettypes", "products", "system.views" ] 

O db.getCollectionInfos() Método


O db.getCollectionInfos() O método retorna uma matriz de documentos com informações de coleção ou exibição, como nome e opções, para o banco de dados atual. Os resultados dependem do privilégio do usuário.

Aqui está um exemplo de como chamá-lo sem nenhum argumento:
db.getCollectionInfos()

Resultado:
[
    {
        "name" : "employees",
        "type" : "collection",
        "options" : {
            
        },
        "info" : {
            "readOnly" : false,
            "uuid" : UUID("07e89c25-8842-4331-a1a9-96fe0b4745dc")
        },
        "idIndex" : {
            "v" : 2,
            "key" : {
                "_id" : 1
            },
            "name" : "_id_"
        }
    },
    {
        "name" : "pets",
        "type" : "collection",
        "options" : {
            
        },
        "info" : {
            "readOnly" : false,
            "uuid" : UUID("91d1c6d8-8516-455d-a3c2-b157e1998f8c")
        },
        "idIndex" : {
            "v" : 2,
            "key" : {
                "_id" : 1
            },
            "name" : "_id_"
        }
    },
    {
        "name" : "pettypes",
        "type" : "view",
        "options" : {
            "viewOn" : "pets",
            "pipeline" : [
                {
                    "$project" : {
                        "type" : 1
                    }
                }
            ]
        },
        "info" : {
            "readOnly" : true
        }
    },
    {
        "name" : "products",
        "type" : "collection",
        "options" : {
            "capped" : true,
            "size" : 7500544,
            "max" : 7000
        },
        "info" : {
            "readOnly" : false,
            "uuid" : UUID("cb084959-f374-4f51-bbed-8998c13dcbe2")
        },
        "idIndex" : {
            "v" : 2,
            "key" : {
                "_id" : 1
            },
            "name" : "_id_"
        }
    },
    {
        "name" : "system.views",
        "type" : "collection",
        "options" : {
            
        },
        "info" : {
            "readOnly" : false,
            "uuid" : UUID("3f458338-0678-4d0f-a0cf-eacbd43c8cad")
        },
        "idIndex" : {
            "v" : 2,
            "key" : {
                "_id" : 1
            },
            "name" : "_id_"
        }
    }
]


A definição de db.getCollectionInfos() na verdade fica assim:
db.getCollectionInfos(filter, nameOnly, authorizedCollections)

Então podemos usar o filter parâmetro para filtrar a lista de coleções com base em uma expressão de consulta. Isso pode ser aplicado em qualquer campo retornado pelo método.

Você também pode usar o nameOnly parâmetro para especificar que o método deve retornar apenas os nomes das coleções e visualizações.

As authorizedCollections parâmetro, quando definido como true e usado com nameOnly: true , permite que um usuário sem o privilégio necessário (ou seja, ação listCollections no banco de dados) execute o comando quando o controle de acesso for aplicado. Nesse caso, o comando retorna apenas as coleções para as quais o usuário possui privilégios.

Exemplo de uso de db.getCollectionInfos() com estes parâmetros:
db.getCollectionInfos( {}, true, true )

Resultado:
[
    {
        "name" : "employees",
        "type" : "collection"
    },
    {
        "name" : "pets",
        "type" : "collection"
    },
    {
        "name" : "pettypes",
        "type" : "view"
    },
    {
        "name" : "products",
        "type" : "collection"
    },
    {
        "name" : "system.views",
        "type" : "collection"
    }
]


Aqui está um onde eu filtrei apenas um nome específico:
db.getCollectionInfos( { name: "pets" }, true, true )

Resultado:
 [ { "name" : "pets", "type" : "collection" } ] 

E aqui está o que acontece quando eu removo os dois últimos argumentos:
db.getCollectionInfos( { name: "pets" } )

Resultado:
[
    {
        "name" : "pets",
        "type" : "collection",
        "options" : {
            
        },
        "info" : {
            "readOnly" : false,
            "uuid" : UUID("91d1c6d8-8516-455d-a3c2-b157e1998f8c")
        },
        "idIndex" : {
            "v" : 2,
            "key" : {
                "_id" : 1
            },
            "name" : "_id_"
        }
    }
]