MongoDB'deki tüm koleksiyonlar nasıl dışa aktarılır?

Şu komutla MongoDB'deki tüm koleksiyonları dışa aktarmak istiyorum:

mongoexport -d dbname -o Mongo.json

Sonuç:
Koleksiyon belirtilmedi!

El kitabı, bir koleksiyon belirtmezseniz tüm koleksiyonların dışa aktarılacağını belirtir.
Ancak, bu neden çalışmıyor?

http://docs.mongodb.org/manual/reference/mongoexport/#cmdoption-mongoexport--collection

Benim MongoDB versiyonum 2.0.6.

Tembel insanlar için kullanın mongodump, daha hızlı:

mongodump -d <database_name> -o <directory_backup>

Ve "geri yüklemek / içe aktarmak" için (directory_backup / dump / dizininden):

mongorestore -d <database_name> <directory_backup>

Bu şekilde, tüm koleksiyonlarla ayrı ayrı uğraşmanıza gerek kalmaz. Sadece veritabanını belirtin.

Büyük veri depoları için mongodump/ kullanmamanızı önereceğim . Çok yavaştır ve 10 / 20GB veriyi geçtiğinizde geri yüklenmesi saatler sürebilir.mongorestore

Bunun için bash senaryosu yazdım. Sadece 2 parametre ile çalıştırın (veritabanı adı, dosyaları saklamak için dir).

#!/bin/bash

if [ ! $1 ]; then
        echo " Example of use: $0 database_name [dir_to_store]"
        exit 1
fi
db=$1
out_dir=$2
if [ ! $out_dir ]; then
        out_dir="./"
else
        mkdir -p $out_dir
fi

tmp_file="fadlfhsdofheinwvw.js"
echo "print('_ ' + db.getCollectionNames())" > $tmp_file
cols=`mongo $db $tmp_file | grep '_' | awk '{print $2}' | tr ',' ' '`
for c in $cols
do
    mongoexport -d $db -c $c -o "$out_dir/exp_${db}_${c}.json"
done
rm $tmp_file

Sunucudan bir mongodump oluşturmak ve kullanıcı adı ve parolası olan başka bir sunucu / yerel makine almak için aşağıdaki adımları izleyin.

1. mongodump -d dbname -o dumpname -u username -p password
2. scp -r user@remote:~/location/of/dumpname ./
3. mongorestore -d dbname dumpname/dbname/ -u username -p password

Tüm koleksiyonları mongodump kullanarak dışa aktarmak için aşağıdaki komutu kullanın

mongodump -d database_name -o directory_to_store_dumps

Geri yüklemek için bu komutu kullanın

mongorestore -d database_name directory_backup_where_mongodb_tobe_restored

Lütfen Mongo DB'nizi nereye kurduğunuzu bize bildirin. (Ubuntu veya Windows'da)

• Pencereler için:

  1. Dışa aktarmadan önce cmd isteminde Mongo DB'nize bağlanmalı ve yerel ana makinenize bağlanabildiğinizden emin olmalısınız.
  2. Şimdi yeni bir cmd istemi açın ve aşağıdaki komutu yürütün,

  mongodump --db veritabanı adı - kaydetmek için çıkış yolu
  örn: mongodump --db mydb --out c: \ TEMP \ op.json

  3. Daha fazla bilgi için https://www.youtube.com/watch?v=hOCp3Jv6yKo adresini ziyaret edin .

• Ubuntu için:

  1. Mongo DB'nin kurulu olduğu terminalinize giriş yapın ve Mongo DB'nize bağlanabildiğinizden emin olun.
  2. Şimdi yeni bir terminal açın ve aşağıdaki komutu yürütün,

  mongodump -d veritabanı adı -o kaydedilecek dosya adı
  örneğin: mongodump -d mydb -o output.json

  3. Daha fazla bilgi için https://www.youtube.com/watch?v=5Fwd2ZB86gg adresini ziyaret edin .

Önceki cevaplar iyi açıkladı, uzaktan şifre korumalı bir veritabanı ile uğraşıyorsanız yardımınıza cevabımı ekliyorum

mongodump --host xx.xxx.xx.xx --port 27017 --db your_db_name --username your_user_name --password your_password --out /target/folder/path

Mongolab.com gibi bir uzak mongoDB sunucusunu bağlamak istiyorsanız, bağlantı kimlik bilgilerini (ör.

mongoexport -h id.mongolab.com:60599 -u username -p password -d mydb -c mycollection -o mybackup.json

Eğer bson biçiminde bir sorun yoksa, aynı -d bayrağına sahip mongodump yardımcı programını kullanabilirsiniz. Tüm koleksiyonları döküm dizinine (varsayılan, -o seçeneği ile değiştirilebilir) bson formatında dökecektir. Daha sonra bu dosyaları mongorestore yardımcı programını kullanarak içe aktarabilirsiniz.

Sen kullanabilirsiniz mongo --eval 'printjson(db.getCollectionNames())'koleksiyonları listesini almak için ve sonra hepsini bir mongoexport yapmak. İşte yakutta bir örnek

  out = `mongo  #{DB_HOST}/#{DB_NAME} --eval "printjson(db.getCollectionNames())"`

  collections = out.scan(/\".+\"/).map { |s| s.gsub('"', '') }

  collections.each do |collection|
    system "mongoexport --db #{DB_NAME}  --collection #{collection}  --host '#{DB_HOST}' --out #{collection}_dump"
  end

Windows toplu komut dosyası sürümüne ihtiyacım vardı. Bu iş parçacığı yararlı oldu, bu yüzden ben de benim cevap katkıda olacağını düşündüm.

mongo "{YOUR SERVER}/{YOUR DATABASE}" --eval "rs.slaveOk();db.getCollectionNames()" --quiet>__collections.txt
for /f %%a in ('type __collections.txt') do @set COLLECTIONS=%%a
for %%a in (%COLLECTIONS%) do mongoexport --host {YOUR SERVER} --db {YOUR DATABASE} --collection %%a --out data\%%a.json
del __collections.txt

set /p COLLECTIONS=<__collections.txtKıvrık for /fyöntemi kullanarak bazı sorunlar yaşadım .

Çok basit bir yaklaşımın benim için işe yaradığına dair çok kıvrımlı örnekler denedikten sonra buldum.

Sadece yerel bir db dökümü almak ve uzak bir örnekte almak istedim:

yerel makinede:

mongodump -d databasename

daha sonra sunucu makineme dökümü scp'd:

scp -r dump user@xx.xxx.xxx.xxx:~

sonra dökümün üst dizininden:

mongorestore 

ve veritabanını içeri aktardı.

Mongodb hizmetinin elbette çalıştığını varsayarsak.

İsterseniz, tüm koleksiyonları belirtmeden csv'ye --fieldsdışa aktarabilirsiniz (tüm alanları dışa aktarır).

Gönderen http://drzon.net/export-mongodb-collections-to-csv-without-specifying-fields/ bu bash komut dosyasını çalıştırmak

OIFS=$IFS;
IFS=",";

# fill in your details here
dbname=DBNAME
user=USERNAME
pass=PASSWORD
host=HOSTNAME:PORT

# first get all collections in the database
collections=`mongo "$host/$dbname" -u $user -p $pass --eval "rs.slaveOk();db.getCollectionNames();"`;
collections=`mongo $dbname --eval "rs.slaveOk();db.getCollectionNames();"`;
collectionArray=($collections);

# for each collection
for ((i=0; i<${#collectionArray[@]}; ++i));
do
    echo 'exporting collection' ${collectionArray[$i]}
    # get comma separated list of keys. do this by peeking into the first document in the collection and get his set of keys
    keys=`mongo "$host/$dbname" -u $user -p $pass --eval "rs.slaveOk();var keys = []; for(var key in db.${collectionArray[$i]}.find().sort({_id: -1}).limit(1)[0]) { keys.push(key); }; keys;" --quiet`;
    # now use mongoexport with the set of keys to export the collection to csv
    mongoexport --host $host -u $user -p $pass -d $dbname -c ${collectionArray[$i]} --fields "$keys" --csv --out $dbname.${collectionArray[$i]}.csv;
done

IFS=$OIFS;

Tüm koleksiyonları tüm veritabanlarına dökmek istiyorsanız (orijinal sorucının amacının geniş bir yorumu).

mongodump

Tüm veritabanları ve koleksiyonlar, 'geçerli' konumda 'döküm' olarak adlandırılan bir dizinde oluşturulacak

Mongodump komutunu kullanarak yapabilirsiniz

Adım 1: Komut istemini açın

Adım 2: MongoDB kurulumunuzun bin klasörüne gidin (C: \ Program Files \ MongoDB \ Server \ 4.0 \ bin)

3.Adım: Ardından aşağıdaki komutu yürütün

mongodump -d your_db_name -o destination_path

your_db_name = testiniz

destination_path = C: \ Kullanıcılar \ HP \ Masaüstü

Dışa aktarılan dosyalar destination_path \ your_db_name klasöründe oluşturulur (bu örnekte C: \ Users \ HP \ Desktop \ test)

Kaynaklar: o7planning

Bunun oldukça eski bir soru olduğunu ve dizinler de dahil olmak üzere% 100 sadık bir sonuç istiyorsanız mongodump / mongorestore'un açıkça doğru yol olduğunu anlıyorum.

Ancak, özellikle tuhaf bir şey olmaması koşuluyla, MongoDB'nin eski ve yeni sürümleri arasında ileri ve geri uyumlu olabilecek hızlı ve kirli bir çözüme ihtiyacım vardı. Bunun için asıl sorunun cevabını istedim.

Yukarıda kabul edilebilir başka çözümler de var, ancak bu Unix boru hattı nispeten kısa ve tatlı:

mongo --quiet mydatabase --eval "db.getCollectionNames().join('\n')" | \
grep -v system.indexes | \
xargs -L 1 -I {} mongoexport -d mydatabase -c {} --out {}.json

Bu, .jsonher koleksiyon için uygun şekilde adlandırılmış bir dosya üretir .

Veritabanı adının ("veritabanım") iki kez göründüğünü unutmayın. Ben veritabanı yerel olduğunu ve kimlik bilgilerini geçirmek gerekmez ama her ikisi ile bunu yapmak kolay olduğunu varsayıyorum mongovemongoexport .

grep -vUnutmak için kullanıyorum system.indexes, çünkü MongoDB'nin eski bir sürümünün bir sistem koleksiyonunu daha yeni bir sistemden yorumlamaya çalışmasını istemiyorum. Bunun yerine uygulamamın ensureIndexdizinleri yeniden oluşturmak için olağan çağrılarını yapmasına izin veriyorum .

aşağıdaki komutu kullanarak zip dosyası oluşturabilirsiniz. Sağlanan {dbname} veritabanının zip dosyasını oluşturacaktır. Daha sonra aşağıdaki zip dosyasını mongo DB'nize aktarabilirsiniz.

Window filepath=C:\Users\Username\mongo 

mongodump --archive={filepath}\+{filename}.gz --gzip --db {dbname}

Dışa aktarılan bir veritabanını geri yüklerken benim için işe yarayanlar:

mongorestore -d 0 ./0 --drop

burada ./ dışa aktarılan bson dosyalarını içerir. --dropMevcut verilerin üzerine yazılacağını unutmayın .

her koleksiyonu veritabanından dışa / içe aktarmak için mongoexport ve mongoimport kullanmak istiyorsanız , bu yardımcı programın sizin için yararlı olabileceğini düşünüyorum . Benzer programı birkaç kez kullandım;

LOADING=false

usage()
{
    cat << EOF
    usage: $0 [options] dbname

    OPTIONS:
        -h      Show this help.
        -l      Load instead of export
        -u      Mongo username
        -p      Mongo password
        -H      Mongo host string (ex. localhost:27017)
EOF
}

while getopts "hlu:p:H:" opt; do
    MAXOPTIND=$OPTIND

    case $opt in 
        h)
            usage
            exit
            ;;
        l)
            LOADING=true
            ;;
        u)
            USERNAME="$OPTARG"
            ;;
        p) 
            PASSWORD="$OPTARG"
            ;;
        H)
            HOST="$OPTARG"
            ;;
        \?)
            echo "Invalid option $opt"
            exit 1
            ;;
    esac
done

shift $(($MAXOPTIND-1))

if [ -z "$1" ]; then
    echo "Usage: export-mongo [opts] <dbname>"
    exit 1
fi

DB="$1"
if [ -z "$HOST" ]; then
    CONN="localhost:27017/$DB"
else
    CONN="$HOST/$DB"
fi

ARGS=""
if [ -n "$USERNAME" ]; then
    ARGS="-u $USERNAME"
fi
if [ -n "$PASSWORD" ]; then
    ARGS="$ARGS -p $PASSWORD"
fi

echo "*************************** Mongo Export ************************"
echo "**** Host:      $HOST"
echo "**** Database:  $DB"
echo "**** Username:  $USERNAME"
echo "**** Password:  $PASSWORD"
echo "**** Loading:   $LOADING"
echo "*****************************************************************"

if $LOADING ; then
    echo "Loading into $CONN"
    tar -xzf $DB.tar.gz
    pushd $DB >/dev/null

    for path in *.json; do
        collection=${path%.json}
        echo "Loading into $DB/$collection from $path"
        mongoimport $ARGS -d $DB -c $collection $path
    done

    popd >/dev/null
    rm -rf $DB
else
    DATABASE_COLLECTIONS=$(mongo $CONN $ARGS --quiet --eval 'db.getCollectionNames()' | sed 's/,/ /g')

    mkdir /tmp/$DB
    pushd /tmp/$DB 2>/dev/null

    for collection in $DATABASE_COLLECTIONS; do
        mongoexport --host $HOST -u $USERNAME -p $PASSWORD -db $DB -c $collection --jsonArray -o $collection.json >/dev/null
    done

    pushd /tmp 2>/dev/null
    tar -czf "$DB.tar.gz" $DB 2>/dev/null
    popd 2>/dev/null
    popd 2>/dev/null
    mv /tmp/$DB.tar.gz ./ 2>/dev/null
    rm -rf /tmp/$DB 2>/dev/null
fi

Sunucudaki tüm dbs'leri, dbs çağrıldığından endişe etmeden yedeklemek istiyorsanız, aşağıdaki kabuk komut dosyasını kullanın:

#!/bin/sh

md=`which mongodump`
pidof=`which pidof`
mdi=`$pidof mongod`
dir='/var/backup/mongo'

if [ ! -z "$mdi" ]
   then
        if [ ! -d "$dir" ]
           then
               mkdir -p $dir
           fi
        $md --out $dir >/dev/null 2>&1
   fi

Bu, hiçbiri belirtilmezse tüm DB'leri yedekleyecek mongodump yardımcı programını kullanır.

Bunu cronjob'ınıza koyabilirsiniz ve sadece mongod işlemi çalışıyorsa çalışır. Ayrıca yoksa yedek dizini de oluşturur.

Her DB yedeklemesi ayrı bir dizine yazılır, böylece tek tek DB'leri genel dökümden geri yükleyebilirsiniz.

İlk olarak, Mongo DB'yi başlatın - bunun için yola gidin ->

C: \ Program Files \ MongoDB \ Server \ 3.2 \ bin ve MongoDB sunucusunu başlatmak için mongod.exe dosyasına tıklayın .

Windows'ta Dışa Aktarma Komutu

• Windows'daki MongoDB veritabanını, dahili IP adresi ve bağlantı noktasıyla uzak sunucudan C: / Users / Desktop / temp klasöründeki "uzak sunucudan" yerel makineye aktarma komutu.

C:> mongodump --host remote_ip_adresi: 27017 --db -o C: / Kullanıcılar / Masaüstü / geçici klasör

Windows'ta İçe Aktarma Komutu

• Windows'da MongoDB veritabanını yerel makine dizininden "uzak sunucuya" alma komutu C: / Users / Desktop / temp-folder / db-dir

C:> mongorestore --host = ip --port = 27017 -d C: / Kullanıcılar / Masaüstü / geçici klasör / db-dir

#mongodump using sh script 
#!/bin/bash
TIMESTAMP=`date +%F-%H%M`
APP_NAME="folder_name"
BACKUPS_DIR="/xxxx/tst_file_bcup/$APP_NAME"
BACKUP_NAME="$APP_NAME-$TIMESTAMP"
/usr/bin/mongodump -h 127.0.0.1 -d <dbname> -o $BACKUPS_DIR/$APP_NAME/$BACKUP_NAME
tar -zcvf $BACKUPS_DIR/$BACKUP_NAME.tgz $BACKUPS_DIR/$APP_NAME/$BACKUP_NAME
rm -rf /home/wowza_analytics_bcup/wowza_analytics/wowza_analytics
### 7 days old backup delete automaticaly using given command

find /home/wowza_analytics_bcup/wowza_analytics/ -mindepth 1 -mtime +7 -delete

1. Bağlantıyı Aç
2. Sunucuyu başlatın
3. yeni Komut istemi aç

İhracat:

mongo/bin> mongoexport -d webmitta -c domain -o domain-k.json

İthalat:

mongoimport -d dbname -c newCollecionname --file domain-k.json

Nerede

webmitta(db name)
domain(Collection Name)
domain-k.json(output file name)

Ne yapmak istediğinize bağlı olarak birden fazla seçenek var

1) Veritabanınızı başka bir mongo veritabanına vermek istiyorsanız, kullanmalısınız mongodump. Bu, JSON'un sahip olmadığı meta verilere sahip bir BSON dosyaları klasörü oluşturur.

mongodump
mongorestore --host mongodb1.example.net --port 37017 dump/

2) Veritabanınızı JSON'a dışa aktarmak istiyorsanız ,mongoexport bunu tek seferde bir koleksiyon yapmak zorunda kalmadan kullanabilirsiniz (bu tasarım gereğidir). Ancak tüm veritabanını mongodumpvermek ve sonra JSON dönüştürmek en kolay olduğunu düşünüyorum .

# -d is a valid option for both mongorestore and mongodump

mongodump -d <DATABASE_NAME>
for file in dump/*/*.bson; do bsondump $file > $file.json; done

Döküm için, DB'niz aşağıdaki CMD'yi takip eder

   mongodump -d <your d name> -o <dump path>
Ex:mongodump -d qualetics -o D:\dbpackup\qualetics

JSON biçiminde dışa aktarmak için bunu görebileceğiniz komutları izleyerek yapın.

mongoexport --db dbname --collection collectionName --out directoryPATH/JSONfileName.json