¿Cómo ejecutar comandos mongo a través de scripts de shell?

Quiero ejecutar mongocomandos en el script de shell, por ejemplo, en un script test.sh:

#!/bin/sh
mongo myDbName
db.mycollection.findOne()
show collections

Cuando ejecuto este script vía ./test.sh, se establece la conexión con MongoDB, pero no se ejecutan los siguientes comandos.

¿Cómo ejecutar otros comandos a través del script de shell test.sh?

También puede evaluar un comando usando la --evalbandera, si es solo un comando.

mongo --eval "printjson(db.serverStatus())"

Tenga en cuenta: si está utilizando operadores Mongo, comenzando con un signo $, querrá rodear el argumento eval entre comillas simples para evitar que el shell evalúe al operador como una variable de entorno:

mongo --eval 'db.mycollection.update({"name":"foo"},{$set:{"this":"that"}});' myDbName

De lo contrario, puede ver algo como esto:

mongo --eval "db.test.update({\"name\":\"foo\"},{$set:{\"this\":\"that\"}});"
> E QUERY    SyntaxError: Unexpected token :

Pon tu script mongo en un .jsarchivo.

Luego ejecuta mongo < yourFile.js

Ex:

El archivo demo.js // tiene su script

use sample  //db name
show collections

mantenga este archivo en "c: \ db-scripts"

Luego, en cmd prompt, vaya a "c: \ db-scripts"

C:\db-scripts>mongo < demo.js

Esto ejecutará el código en mongo y muestra la salida

C:\db-scripts>mongo < demo.js
Mongo shell version: 3.0.4
Connecting to: test
switched to db sample
users   //collection name
tasks   //collection name
bye
C:\db-scripts>

Esto funciona para mí en Linux:

mongo < script.js

Pon esto en un archivo llamado test.js:

db.mycollection.findOne()
db.getCollectionNames().forEach(function(collection) {
  print(collection);
});

luego ejecútalo con mongo myDbName test.js.

También hay una página de documentación oficial sobre esto.

Los ejemplos de esa página incluyen:

mongo server:27017/dbname --quiet my_commands.js
mongo test --eval "printjson(db.getCollectionNames())"

El siguiente script de shell también funcionó muy bien para mí ... definitivamente tuve que usar la redirección que Antonin mencionó al principio ... que me dio la idea de probar el documento aquí.

function testMongoScript {
    mongo <<EOF
    use mydb
    db.leads.findOne()
    db.leads.find().count()
EOF
}

En mi configuración tengo que usar:

mongo --host="the.server.ip:port" databaseName theScript.js 

Uso la sintaxis "heredoc", que menciona David Young. Pero hay una trampa:

#!/usr/bin/sh

mongo <db> <<EOF
db.<collection>.find({
  fieldName: { $exists: true }
})
.forEach( printjson );
EOF

Lo anterior NO funcionará, porque la frase "$ existe" será vista por el shell y sustituida con el valor de la variable de entorno llamada "existe". Lo cual, probablemente, no existe, por lo que después de la expansión de shell, se convierte en:

#!/usr/bin/sh

mongo <db> <<EOF
db.<collection>.find({
  fieldName: { : true }
})
.forEach( printjson );
EOF

Para que pase, tienes dos opciones. Uno es feo, uno es bastante agradable. Primero, el feo: escapar de los signos $:

#!/usr/bin/sh

mongo <db> <<EOF
db.<collection>.find({
  fieldName: { \$exists: true }
})
.forEach( printjson );
EOF

NO recomiendo esto, porque es fácil olvidar escapar.

La otra opción es escapar del EOF, así:

#!/usr/bin/sh

mongo <db> <<\EOF
db.<collection>.find({
  fieldName: { $exists: true }
})
.forEach( printjson );
EOF

Ahora, puede poner todos los signos de dólar que desee en su heredoc, y los signos de dólar se ignoran. El lado negativo: eso no funciona si necesita poner parámetros / variables de shell en su script mongo.

Otra opción con la que puedes jugar es meterse con tu shebang. Por ejemplo,

#!/bin/env mongo
<some mongo stuff>

Hay varios problemas con esta solución:

1. Solo funciona si intenta hacer que un script de shell mongo sea ejecutable desde la línea de comandos. No puede mezclar comandos de shell normales con comandos de shell mongo. Y todo lo que ahorra al hacerlo es no tener que escribir "mongo" en la línea de comando ... (razón suficiente, por supuesto)

2. Funciona exactamente como "mongo <some-js-file>", lo que significa que no le permite usar el comando "use <db>".

Intenté agregar el nombre de la base de datos al shebang, que pensarías que funcionaría. Desafortunadamente, la forma en que el sistema procesa la línea shebang, todo después del primer espacio se pasa como un solo parámetro (como si fuera citado) al comando env, y env no puede encontrarlo ni ejecutarlo.

En cambio, debe incrustar el cambio de la base de datos dentro del script en sí, así:

#!/bin/env mongo
db = db.getSiblingDB('<db>');
<your script>

Como con cualquier cosa en la vida, "¡hay más de una forma de hacerlo!"

En caso de que tenga habilitada la autenticación:

mongo -u username -p password --authenticationDatabase auth_db_name < your_script.js

Crea un archivo de script; escribir comandos:

#!/bin/sh
mongo < file.js

En file.jsescriba su consulta mongo:

db.collection.find({"myValue":null}).count();

Qué tal esto:

echo "db.mycollection.findOne()" | mongo myDbName
echo "show collections" | mongo myDbName

Según lo sugerido theTuxRacer, puede usar el comando eval , para aquellos que lo faltan como yo, también puede agregar su nombre de base de datos si no está tratando de preformar la operación en la base de datos predeterminada.

mongo <dbname> --eval "printjson(db.something.find())"

Gracias printf! En un entorno Linux, aquí hay una mejor manera de hacer que solo un archivo ejecute el programa. Digamos que tiene dos archivos, mongoCmds.jscon múltiples comandos:

use someDb
db.someColl.find()

y luego el archivo shell del controlador, runMongoCmds.sh

mongo < mongoCmds.js

En su lugar, tenga solo un archivo, runMongoCmds.sh que contenga

printf "use someDb\ndb.someColl.find()" | mongo

Bash printfes mucho más robusto que echoy permite que los \ncomandos entre los fuercen en varias líneas.

mongo <<EOF
use <db_name>
db.getCollection("<collection_name>").find({})
EOF

En mi caso, puedo usar convenientemente \ncomo separador para el próximo comando mongo que quiero ejecutar y luego canalizarlos amongo

echo $'use your_db\ndb.yourCollection.find()' | mongo

--la bandera también se puede usar para archivos javascript

 mongo --shell /path/to/jsfile/test.js 

mongo db_name --eval "db.user_info.find().forEach(function(o) {print(o._id);})"

Recientemente migró de mongodb a Postgres. Así es como usé los scripts.

mongo < scripts.js > inserts.sql

Lea la scripts.jsredirección de salida y hacia inserts.sql.

scripts.js Se ve como esto

use myDb;
var string = "INSERT INTO table(a, b) VALUES";
db.getCollection('collectionName').find({}).forEach(function (object) {
    string += "('" + String(object.description) + "','" + object.name + "'),";
});
print(string.substring(0, string.length - 1), ";");

inserts.sql Se ve como esto

INSERT INTO table(a, b) VALUES('abc', 'Alice'), ('def', 'Bob'), ('ghi', 'Claire');

Si desea manejarlo con una línea, es una manera fácil.

file.sh --> db.EXPECTED_COLLECTION.remove("_id":1234)

cat file.sh | mongo <EXPECTED_COLLECTION>

Yo escribí las diversas opciones para ejecutar una secuencia de comandos shell Mongo desde un script Bash más grande

Solución de script de shell único con capacidad para pasar argumentos mongo ( --quiet, dbname, etc.):

#!/usr/bin/env -S mongo --quiet localhost:27017/test

cur = db.myCollection.find({});
while(cur.hasNext()) {
  printjson(cur.next());
}

La -Sbandera podría no funcionar en todas las plataformas.

Cuando utilizo un conjunto de réplicas, las escrituras deben realizarse en PRIMARY, por lo que generalmente uso una sintaxis como esta que evita tener que averiguar qué host es el maestro:

mongo -host myReplicaset/anyKnownReplica