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

Ponga su script mongo en un archivo .js.

Luego ejecuta mongo < yourFile.js

Ex:

Demo.js / / el archivo tiene su script

use sample  //db name
show collections

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

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

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

Esto ejecutará el código en mongo y mostrará 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í bajo 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.

Hay una página de documentación oficial sobre esto también.

Ejemplos de esa página incluyen:

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

El script de shell a continuación también funcionó muy bien para mí... definite tuvo que usar la redirección que Antonin mencionó al principio... eso 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 

¿qué tal esto:

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

Como sugiere theTuxRacer, puede usar el comando eval, para aquellos que lo están perdiendo como yo, también puede agregar el nombre de su 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())"

Utilizo la sintaxis "heredoc", que David Young menciona. 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 "exists exists" será vista por el shell y sustituida por el valor de la variable de entorno llamada "exists."Que, 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 signs signos:

#!/usr/bin/sh

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

I no recomiendo esto, porque es fácil olvidarse de 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 meterte con tu shebang. Por ejemplo,

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

Hay varios problemas con esto solución:

1. Solo funciona si está intentando hacer un script de shell de mongo ejecutable desde la línea de comandos. No puedes mezclar comandos de shell regulares con comandos de shell de mongo. Y todo lo que guarda al hacerlo es no tener que escribir "mongo" en la línea de comandos... (razón suficiente, por supuesto)

2. Funciona exactamente como " mongo ", lo que significa que no le permite usar el comando" use ".

He intentado agregar el nombre de la base de datos para el shebang, que usted pensaría 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 se citara) al comando env, y env falla al encontrarlo y ejecutarlo.

En su lugar, debe incrustar el cambio de la base de datos dentro del propio script, de la siguiente manera:

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

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

En caso de que tenga la autenticación habilitada:

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

Gracias printf! En un entorno Linux, esta es una mejor manera de tener un solo archivo ejecutando el programa. Digamos que tienes dos archivos, mongoCmds.js con múltiples comandos:

use someDb
db.someColl.find()

Y luego el archivo de shell del controlador, runMongoCmds.sh

mongo < mongoCmds.js

En su lugar, tener un solo archivo, runMongoCmds.sh que contengan

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

El printf de Bash es mucho más robusto que echo y permite que el \n entre comandos los fuerce en múltiples líneas.

Crear un archivo de script; escribir comandos:

#!/bin/sh
mongo < file.js

En file.js escriba su consulta mongo:

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

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

Flag shell flag también se puede usar para archivos javascript

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

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

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

cat file.sh | mongo <EXPECTED_COLLECTION>

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

En mi caso, puedo usar convenientemente \n como separador para el siguiente comando mongo que quiero ejecutar y luego canalizarlos a mongo

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

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

mongo < scripts.js > inserts.sql

Lee el scripts.js y redirige la salida a inserts.sql.

scripts.js se ve así

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 así

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