PouchDB - Szybki przewodnik

Ten rozdział zawiera krótkie wprowadzenie do PouchDB wraz z jego funkcjami i sposobem działania.

Co to jest PouchDB?

PouchDB to oprogramowanie typu open source in-browser database APInapisane w JavaScript. Jest wzorowany na Couch DB & minuss; baza danych NoSQL. Korzystając z tego interfejsu API, możemy budować aplikacje działające w trybie offline i online. Wewnętrznie używa WebSQL i IndexedDB do przechowywania danych.

Jak to działa?

W PouchDB, gdy aplikacja jest offline, dane są przechowywane lokalnie przy użyciu WebSQL i IndexedDB w przeglądarce. Gdy aplikacja wróci do trybu online, zostanie zsynchronizowana z CouchDB i kompatybilnymi serwerami.

Korzystając z PouchDB, możesz bezproblemowo komunikować się zarówno z lokalnymi, jak i zdalnymi bazami danych, nie zauważając żadnej różnicy.

Funkcje PouchDB

Oto cechy PouchDB -

Cross Browser - API dostarczane przez PouchDB działa tak samo w każdym środowisku, dzięki czemu możemy uruchomić aplikację PouchDB w różnych przeglądarkach.
Light Weight - PouchDB to bardzo lekki interfejs API, można go również łatwo dołączyć za pomocą tagu skryptu.
Easy to Learn - Jeśli masz wcześniejszą znajomość dowolnego języka programowania, łatwo jest nauczyć się PouchDB.
Open Source - PouchDB jest aplikacją typu Open Source i jest dostępna na GitHub.

Zalety PouchDB

Oto zalety PouchDB -

Ponieważ PouchDB znajduje się w przeglądarce, nie ma potrzeby wykonywania zapytań w sieci, co powoduje szybsze wykonywanie zapytań.
Możesz zsynchronizować dane z dowolnym obsługiwanym serwerem, dzięki czemu możesz uruchamiać aplikacje zarówno w trybie online, jak i offline.

Przeglądarki obsługujące PouchDB

Oto przeglądarki obsługujące PouchDB -

Firefox 29+ (w tym Firefox OS i Firefox dla Androida)
Chrome 30+
Safari 5+
Internet Explorer 10+
Opera 21+
Android 4.0+
iOS 7.1+
Windows Phone 8+

W tym rozdziale wyjaśniono, jak pobrać i zainstalować PouchDB w systemie.

Instalowanie PouchDB

Aby pracować z PouchDB, musisz pobrać plik .jsplik i umieść go w swoim skrypcie. Poniżej przedstawiono kroki instalacji PouchDB.

Krok 1

Odwiedź stronę główną serwisu PouchDB, klikając poniższy link -

https://PouchDB.com/

Krok 2

Kliknij przycisk Pobierz w prawym górnym rogu strony internetowej, jak pokazano na powyższym zrzucie ekranu. Spowoduje to pobraniePouchDB-5.3.0.min.js w twoim systemie.

Krok 3

Skopiuj i wklej PouchDB-5.3.0.min.js do katalogu roboczego i dołącz go do JavaScript, jak pokazano w poniższym poleceniu.

<script src = "PouchDB-5.3.0.min.js"></script>

Instalowanie Pouch za pomocą Node.js

Możesz także zainstalować PouchDB jako moduł Node.js. Poniżej przedstawiono kroki instalacji PouchDB przy użyciu Node.js.

Krok 1

Zainstaluj Node.js, wykonując kroki podane w sekcji Instalowanie Node.js naszego samouczka skryptu kawy .

Krok 2

Otwórz wiersz polecenia i wykonaj następujące polecenie. Spowoduje to zainstalowanie modułu węzła PouchDB w twoim systemie.

npm install --save PouchDB

Pobieranie CouchDB

W trybie offline PouchDB przechowuje dane lokalnie i działa jak aplikacja. Możesz uzyskać do niego dostęp online, łącząc się z kompatybilnymi serwerami. Jak wiemy, PouchDB można podłączyć do CouchDB, więc zainstalujmy też CouchDB. Poniżej przedstawiono kroki instalacji CouchDB.

Krok 1

Oficjalna strona CouchDB to http://couchdb.apache.org. Jeśli klikniesz w podany link, możesz uzyskać stronę główną oficjalnej witryny CouchDB, jak pokazano na poniższym zrzucie ekranu.

Krok 2

Jeśli klikniesz przycisk pobierania, który otworzy stronę, na której dostępne są linki do pobrania CouchDB w różnych formatach. Poniższa migawka ilustruje to samo.

Krok 3

Wybierz łącze pobierania dla systemów Windows i wybierz jeden z dostarczonych serwerów lustrzanych, aby rozpocząć pobieranie.

Instalowanie CouchDB

Plik wykonywalny systemu Windows setup-couchdb-1.6.1_R16B02.exeplik zostanie pobrany do twojego systemu. Uruchom plik instalacyjny i kontynuuj instalację.

Po pomyślnym zainstalowaniu CouchDB w systemie otwórz folder, w którym zainstalowano CouchDB, przejdź do folderu bin i uruchom serwer, uruchamiając plik skryptu o nazwie couchdb.bat.

Po instalacji otwórz wbudowany interfejs sieciowy CouchDB, odwiedzając poniższe łącze - http://127.0.0.1:5984/. Jeśli wszystko pójdzie dobrze, otrzymasz stronę internetową, która będzie miała następujący wynik.

{                 
   "couchdb":"Welcome","uuid":"c8d48ac61bb497f4692b346e0f400d60",
   "version":"1. 6.1",
   "vendor": {
      "version":"1.6.1","name":"The Apache Software Foundation"
   } 
}

Możesz współdziałać z interfejsem internetowym CouchDB, używając następującego adresu URL -

http://127.0.0.1:5984/_utils/

Spowoduje to wyświetlenie strony indeksu Futon, który jest interfejsem sieciowym CouchDB.

Możesz stworzyć bazę danych w PouchDB za pomocą konstruktora PouchDB.

Składnia

Poniżej znajduje się składnia użycia konstruktora PouchDB. W tym celu musisz podać nazwę bazy danych jako parametr.

new PouchDB(Database_name)

Przykład

Aby utworzyć bazę danych w PouchDB za pomocą node, przede wszystkim musisz wymagać pakietu PouchDB z rozszerzeniem require() metody, a następnie możesz utworzyć bazę danych, jak pokazano w poniższym przykładzie.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');
console.log ("Database created Successfully.");

Zapisz powyższy kod w pliku o nazwie Create_Database.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples>node Create_Database.js

Spowoduje to utworzenie bazy danych lokalnie (możesz zobaczyć folder w bieżącym katalogu) wyświetlając następujący komunikat.

Database created Successfully.

Możesz uzyskać podstawowe informacje o bazie danych za pomocą metody o nazwie info()

Składnia

Poniżej znajduje się składnia używania info()metoda PouchDB. Ta metoda akceptuje funkcję zwrotną.

db.info([callback])

Przykład

Poniżej znajduje się przykład pobierania informacji z bazy danych przy użyciu info()metoda. Tutaj wyświetlamy informacje o nazwie bazy danychmy_database. W przypadku błędu zostanie wyświetlony na konsoli.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Database information
db.info(function(err, info) {
   if (err) {
      return console.log(err);
   } else {
      console.log(info);
   }
});

Zapisz powyższy kod w pliku o nazwie Database_info.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples>node Database_info.js

Spowoduje to wyświetlenie informacji o określonej bazie danych w następujący sposób.

{ 
   doc_count: 0,
   update_seq: 0,
   backend_adapter: 'LevelDOWN',
   db_name: 'my_database',
   auto_compaction: false,
   adapter: 'leveldb' 
}

Informacje o zdalnej bazie danych

W ten sam sposób otrzymujesz informacje o bazie danych, która jest zdalnie zapisywana na serwerze (CouchDB). Aby to zrobić, zamiast nazwy bazy danych, musisz podać ścieżkę do wymaganej bazy danych w CouchDB.

Przykład

Poniżej znajduje się przykład pobierania informacji z bazy danych, która jest zapisana na serwerze CouchDB. Ten kod zawiera informacje o nazwie bazy danychmy_database.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Database information
db.info(function(err, info) {
   if (err) {
      return console.log(err);
   } else {
      console.log(info);
   }
});

Zapisz powyższy kod w pliku o nazwie Database_ Remote_info.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples>node Database_Remote_info.js

Spowoduje to wyświetlenie informacji o określonej bazie danych w następujący sposób.

{ 
   db_name: 'my_database', 
   doc_count: 0, 
   doc_del_count: 0, 
   update_seq: 0, 
   purge_seq: 0, 
   compact_running: false, 
   disk_size: 79, 
   data_size: 0, 
   instance_start_time: '1458209191708486', 
   disk_format_version: 6, 
   committed_update_seq: 0, 
   host: 'http://localhost:5984/my_database/', 
   auto_compaction: false, 
   adapter: 'http' 
}

Możesz usunąć bazę danych w PouchDB za pomocą db.destroy() metoda.

Składnia

Poniżej znajduje się składnia używania db.destroy()metoda. Ta metoda akceptuje funkcję wywołania zwrotnego jako parametr.

db.destroy()

Przykład

Poniżej znajduje się przykład usuwania bazy danych w PouchDB przy użyciu rozszerzenia destroy()metoda. Tutaj usuwamy bazę danych o nazwiemy_database, utworzony w poprzednich rozdziałach.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//deleting database
db.destroy(function (err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log ("Database Deleted”);
   }
});

Zapisz powyższy kod w pliku o nazwie Delete_Database.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocą node jak pokazano niżej.

C:\PouchDB_Examples >node Delete_Database.js

Spowoduje to usunięcie bazy danych o nazwie my_database który jest przechowywany lokalnie, wyświetlając następujący komunikat.

Database Deleted

Usuwanie zdalnej bazy danych

W ten sam sposób możesz usunąć bazę danych przechowywaną zdalnie na serwerze (CouchDB).

Aby to zrobić, zamiast nazwy bazy danych należy podać w CouchDB ścieżkę do bazy danych, która ma zostać usunięta.

Przykład

Załóżmy, że istnieje baza danych o nazwie my_databasena serwerze CouchDB. Następnie, jeśli zweryfikujesz listę baz danych w CouchDB za pomocą adresu URLhttp://127.0.0.1:5984/_utils/index.html otrzymasz następujący zrzut ekranu.

Poniżej znajduje się przykład usuwania bazy danych o nazwie my_database który jest zapisywany na serwerze CouchDB.

//Requiring the package
var PouchDB = require('pouchdb');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//deleting database
db.destroy(function (err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Database Deleted");
   }
});

Zapisz powyższy kod w pliku o nazwie Remote_Database_Delete.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >Remote_Database_Delete.js

Spowoduje to usunięcie określonej bazy danych z PouchDB, wyświetlając następujący komunikat.

Database Deleted

Weryfikacja

Po uruchomieniu powyższego programu, jeśli ponownie odwiedzisz adres URL, otrzymasz następujący zrzut ekranu. Tutaj możesz obserwować tylko dwie bazy danych od tego czasumy_database został usunięty.

Możesz utworzyć dokument w PouchDB za pomocą db.put() metoda.

Składnia

Poniżej przedstawiono składnię korzystania z metody db.put () w PouchDB. Możesz przechowywać dokument, który ma zostać utworzony w PouchDB, w zmiennej i przekazać jako parametr do tej metody. Ponadto ta metoda akceptuje również funkcję wywołania zwrotnego (opcjonalną) jako parametr.

db.put(document, callback)

Przykład

Poniżej znajduje się przykład tworzenia dokumentu w PouchDB przy użyciu put()metoda. Tworzony przez nas dokument powinien mieć format JSON, zestaw par klucz-wartość oddzielonych przecinkiem (,) i ujęta w nawiasy klamrowe ({}).

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the document
doc = {
   _id : '001',
   name: 'Raju',
   age : 23,
   designation : 'Designer'
   }
//Inserting Document
db.put(doc, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document created Successfully");
   }
});

Zapisz powyższy kod w pliku o nazwie Create_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Create_Document.js

Spowoduje to utworzenie danego dokumentu w bazie danych PouchDB o nazwie my_database, który jest przechowywany lokalnie, wyświetlając następujący komunikat.

Document created Successfully

Wstawianie dokumentu do zdalnej bazy danych

Możesz również wstawić dokument do bazy danych, która jest przechowywana zdalnie na serwerze (CouchDB).

Aby to zrobić, zamiast nazwy bazy danych musisz podać ścieżkę do bazy danych, w której chcesz tworzyć dokumenty w CouchDB.

Przykład

Teraz, jeśli klikniesz bazę danych o nazwie my_database, znajdziesz pustą bazę danych, jak pokazano na poniższym zrzucie ekranu.

Poniżej znajduje się przykład wstawienia dokumentu do bazy danych o nazwie my_database który jest zapisywany na serwerze CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the document
doc = {
   _id : '001',
   name: 'Raju',
   age : 23,
   designation : 'Designer'
   }
//Inserting Document
db.put(doc, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document created Successfully");
   }
});

Zapisz powyższy kod w pliku o nazwie Remote_Create_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remote_Create_Document.js

Spowoduje to utworzenie danego dokumentu w bazie danych PouchDB o nazwie my_database który jest przechowywany w CouchDB, wyświetlając następujący komunikat.

Document created Successfully

Weryfikacja

Po wykonaniu powyższego programu, jeśli odwiedzasz my_database Ponownie możesz obserwować utworzony dokument, jak pokazano na poniższym zrzucie ekranu.

Możesz odczytać / pobrać zawartość dokumentu w PouchDB za pomocą db.get() metoda.

Składnia

Poniżej znajduje się składnia używania db.get()metoda PouchDB. Ta metoda akceptujedocument id i opcjonalna funkcja oddzwaniania.

db.get(document, callback)

Przykład

Poniżej znajduje się przykład czytania zawartości dokumentu w PouchDB przy użyciu get() metoda.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Zapisz powyższy kod w pliku o nazwie Read_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocą node, jak pokazano poniżej.

C:\PouchDB_Examples >node Read_Document.js

Odczytuje zawartość podanego dokumentu, który istnieje w nazwie bazy danych my_databasektóry jest przechowywany lokalnie. Na konsoli zostanie wyświetlony następujący komunikat.

{
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _id: '001',
   _rev: '1-ba7f6914ac80098e6f63d2bfb0391637'
}

Czytanie dokumentu ze zdalnej bazy danych

Możesz także odczytać dokument z bazy danych, która jest zdalnie przechowywana na serwerze (CouchDB).

Aby to zrobić, zamiast nazwy bazy danych należy podać ścieżkę do bazy danych w CouchDB, w której znajduje się dokument przeznaczony do odczytania.

Przykład

Klikając na bazę danych o nazwie my_databasemożesz zobaczyć następujący zrzut ekranu. Tutaj możesz zauważyć, że ta baza danych zawiera dokument o identyfikatorze001.

Poniżej znajduje się przykład czytania treści dokumentu o identyfikatorze „001”, Który istnieje w bazie danych o nazwie my_database, który jest przechowywany na serwerze CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Reading the contents of a document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Zapisz powyższy kod w pliku o nazwie Remote_Read_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remote_Read_Document.js

Odczytuje zawartość podanego dokumentu, który istnieje w nazwie bazy danych my_databasektóry jest przechowywany w CouchDB. Na konsoli zostanie wyświetlony następujący komunikat.

{ 
   _id: '001',
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   name: 'Raju',
   age: 23,
   designation: 'Designer' 
}

Zawsze, gdy tworzymy dokument w PouchDB, nowe pole _rev jest generowany i jest znany jako revision marker. Plik_revWartość to niepowtarzalna liczba losowa, za każdym razem, gdy wprowadzamy zmiany w dokumencie, których wartość _rev jest zmieniony.

Możesz zaktualizować istniejący dokument w PouchDB za pomocą (_rev). Aby to zrobić, najpierw pobierz plik_revwartość dokumentu, który chcemy zaktualizować. Teraz umieść zawartość, która ma zostać zaktualizowana, wraz z pobraną_rev value w nowym dokumencie, a na koniec wstaw ten dokument do PouchDB przy użyciu rozszerzenia put() metoda.

Przykład

Załóżmy, że mamy dokument w PouchDB o identyfikatorze 001który zawiera dane osoby. Aby zaktualizować ten dokument, powinniśmy mieć jego numer rewizji. Dlatego w celu pobrania zawartości dokumentu używany jest następujący kod.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Po wykonaniu powyższego kodu otrzymasz następujące dane wyjściowe.

{
   _id: '001',
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   name: 'Raju',
   age: 23,
   designation: 'Designer' 
}

Teraz używając _rev możesz zaktualizować wartość klucza „age”Do 26, jak pokazano w poniższym kodzie.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the document for update
doc = {
   age: 26,
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   }

//Inserting Document
db.put(doc);

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Zapisz powyższy kod w pliku o nazwie Update_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\Pouch_Examples>node Update_Document.js

Spowoduje to zaktualizowanie zawartości danego dokumentu, który istnieje w nazwie bazy danych my_databasektóry jest przechowywany lokalnie. Na konsoli zostanie wyświetlony następujący komunikat.

{ 
   name: 'Raju',
   age: 26,
   designation: 'Designer',
   _id: '001',
   _rev: '2-61b523ccdc4e41a8435bdffbb057a7a5' 
}

Aktualizacja dokumentu w zdalnej bazie danych

Możesz także zaktualizować istniejący dokument w bazie danych, która jest zdalnie przechowywana na serwerze (CouchDB).

W tym celu zamiast nazwy bazy danych należy podać ścieżkę do bazy danych w CouchDB, w której znajduje się dokument przeznaczony do aktualizacji.

Przykład

Klikając na bazę danych o nazwie my_database, możesz zobaczyć następujący zrzut ekranu. Tutaj możesz zauważyć, że ta baza danych zawiera dokument o identyfikatorze001.

Poniżej znajduje się przykład aktualizacji wieku dokumentu o identyfikatorze „001”, Który istnieje w bazie danych o nazwie my_database który jest przechowywany na serwerze CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the document for update
doc = {
   age: 26,
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   }

//Inserting Document
db.put(doc);

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Zapisz powyższy kod w pliku o nazwie Remote_Update_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remote_Update_Document.js

Spowoduje to zaktualizowanie zawartości danego dokumentu, który istnieje w nazwie bazy danych my_databasektóry jest przechowywany w CouchDB. Na konsoli zostanie wyświetlony następujący komunikat.

{
   _id: '001',
   _rev: '2-b9640bffbce582c94308905eed8bb545',
   name: 'Raju',
   age: 26,
   designation: 'Designer' 
}

Możesz usunąć dokument z bazy danych, która istnieje w PouchDB za pomocą db.remove() metoda.

Składnia

Poniżej znajduje się składnia używania db.remove()metoda PouchDB. Do tej metody musimy przejśćid i _revaby usunąć istniejący dokument, jak pokazano w poniższym kodzie. Ta metoda akceptuje opcjonalną funkcję zwrotną. Możemy również przekazać cały dokument zamiast id i _rev.

db. get ( docId, docRev, [callback] )
or
db. get ( docId, docRev, [callback] )

Przykład

Załóżmy, że mamy dokument w PouchDB o identyfikatorze 001które zawierają dane osoby. Aby usunąć ten dokument wraz zid powinniśmy też mieć jego _revnumer. Dlatego pobierz zawartość dokumentu, jak pokazano w poniższym kodzie.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Reading the contents of a Document
db.get('001', function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Wykonanie powyższego kodu daje następujący wynik.

{
   _id: '001',
   _rev: '3-552920d1ca372986fad7b996ce365f5d',
   name: 'Raju',
   age: 23,
   designation: 'Designer' 
}

Teraz używając _rev i id dokumentu, który możesz usunąć za pomocą remove() metoda, jak pokazano w poniższym kodzie.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Deleting an existing document
db.remove('001', '3-552920d1ca372986fad7b996ce365f5d', function(err) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document deleted successfully");
   }
});

Zapisz powyższy kod w pliku o nazwie Delete_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Delete_Document.js

Spowoduje to usunięcie zawartości danego dokumentu, który istnieje w bazie danych o nazwie my_databasektóry jest przechowywany lokalnie. Zostanie wyświetlony następujący komunikat.

Document deleted successfully

Usuwanie dokumentu ze zdalnej bazy danych

Możesz także usunąć istniejący dokument z bazy danych przechowywanej zdalnie na serwerze (CouchDB).

Aby to zrobić, zamiast nazwy bazy danych należy podać ścieżkę do bazy danych w CouchDB, w której znajduje się dokument przeznaczony do odczytania.

Przykład

Klikając na bazę danych o nazwie my_databasemożesz zobaczyć następujący zrzut ekranu. Tutaj możesz zauważyć, że baza danych zawiera dokument o identyfikatorze001.

Poniżej znajduje się przykład usuwania treści dokumentu o identyfikatorze „001”, Który istnieje w bazie danych o nazwie my_database który jest przechowywany na serwerze CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Deleting an existing document
db.remove('001', '3-552920d1ca372986fad7b996ce365f5d', function(err) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Document deleted successfully");
   }
});

Zapisz powyższy kod w pliku o nazwie Remote_Delete_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remote_Delete_Document.js

Spowoduje to usunięcie danego dokumentu, który istnieje w bazie danych o nazwie my_databasektóry jest przechowywany w CouchDB. Zostanie wyświetlony następujący komunikat.

Document deleted successfully

Możesz utworzyć tablicę (pakiet) dokumentów w PouchDB za pomocą rozszerzenia db.bulkDocs()metoda. Podczas tworzenia dokumentów, używając tej metody, jeśli nie podamy wartości _id, w naszym imieniu PouchDB generuje unikalne identyfikatory dla wszystkich dokumentów zbiorczo.

Składnia

Poniżej znajduje się składnia używania db.bulkDocs()metoda PouchDB. Możesz przechowywać wszystkie dokumenty, które mają zostać utworzone w PouchDB w tablicy i przekazać je do tej metody jako parametr. Oprócz tego metoda ta akceptuje również funkcję wywołania zwrotnego (opcjonalną) jako parametr.

db.bulkDocs(docs, [options], [callback])

Przykład

Poniżej znajduje się przykład tworzenia wielu dokumentów w PouchDB przy użyciu db.bulkDocs ()metoda. Tworzone przez nas dokumenty powinny mieć format JSON, zestaw par klucz-wartość oddzielonych przecinkiem (,) i ujęta w nawiasy klamrowe ({}).

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the documents array
doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}
docs = [doc1, doc2, doc3]

//Inserting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents created Successfully");
   }
});

Zapisz powyższy kod w pliku o nazwie Create_Batch.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Create_Batch.js

Spowoduje to utworzenie danego dokumentu w bazie danych PouchDB o nazwie my_databasektóry jest przechowywany lokalnie. Zostanie wyświetlony następujący komunikat.

Documents created Successfully

Wstawianie wsadu do zdalnej bazy danych

Do bazy danych można wstawić szereg dokumentów przechowywanych zdalnie na serwerze (CouchDB).

W tym celu zamiast nazwy bazy danych należy podać ścieżkę do bazy, w której chcemy tworzyć dokumenty w CouchDB.

Przykład

Poniżej znajduje się przykład wstawiania tablicy dokumentów do nazwanej bazy danych my_database który jest zapisywany na serwerze CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the documents array

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

docs = [doc1, doc2, doc3]

//Inserting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents created Successfully");
   }
});

Zapisz powyższy kod w pliku o nazwie Remote_Create_Batch.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remote_Create_Batch.js

Spowoduje to utworzenie podanych dokumentów w bazie danych PouchDB o nazwie my_databasektóry jest przechowywany w CouchDB. Zostanie wyświetlony następujący komunikat.

Document created Successfully

Weryfikacja

Po wykonaniu powyższego programu, jeśli odwiedzasz my_database ponownie możesz obserwować utworzone dokumenty, jak pokazano na poniższym zrzucie ekranu.

Możesz czytać / pobierać wiele / zbiorczo dokumentów z bazy danych w PouchDB za pomocą rozszerzenia allDocs() metoda.

Składnia

Poniżej znajduje się składnia używania db.allDocs()metoda PouchDB. Ta metoda akceptuje opcjonalną funkcję zwrotną.

db.allDocs()

Przykład

Poniżej znajduje się przykład pobierania wszystkich dokumentów w bazie danych o nazwie my_database który jest przechowywany lokalnie przy użyciu db.allDocs()metoda. Ta metoda pobiera tablicę dokumentów w postaci obiektów, aby uzyskać zawartość każdego dokumentu, który należy wywołać jakodocs.rows.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs(function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log (docs.rows);
   }
});

Zapisz powyższy kod w pliku o nazwie Read_All_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Read_All_Document.js

Odczytuje wszystkie dokumenty, które istnieją w wymienionej bazie danych my_databasektóry jest przechowywany lokalnie. Na konsoli zostanie wyświetlony następujący komunikat.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-9dc57f5faa7ea90eeec22eba8bfd05f5' } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-9bf80afcedb9f8b5b35567292affb254' } 
    },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-1204f108e41bf8baf867856d5da16c57' } 
   }
]

Ogólnie, jak pokazano w powyższym wyniku, użycie allDocs() możesz zobaczyć tylko _id, key i _revpola każdego dokumentu. Jednak aby uwzględnić cały dokument w wyniku, musisz wprowadzić opcjonalny parametrinclude_docs prawda, jak pokazano poniżej.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log (docs.rows);
   }
});

Wykonanie powyższego kodu daje listę kompletnych dokumentów w określonych dokumentach, jak pokazano w poniższym kodzie.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-9dc57f5faa7ea90eeec22eba8bfd05f5' },
      doc: { 
         name: 'Ram',
         age: 23,
         Designation: 'Programmer',
         _id: '001',
         _rev: '1-9dc57f5faa7ea90eeec22eba8bfd05f5' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-9bf80afcedb9f8b5b35567292affb254' },
      doc: { 
         name: 'Robert',
         age: 24,
         Designation: 'Programmer',
         _id: '002',
         _rev: '1-9bf80afcedb9f8b5b35567292affb254' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-1204f108e41bf8baf867856d5da16c57' },
      doc: { 
         name: 'Rahim',
         age: 25,
         Designation: 'Programmer',
         _id: '003',
         _rev: '1-1204f108e41bf8baf867856d5da16c57' 
      } 
   }
]

Odczytywanie wsadu ze zdalnej bazy danych

Możesz także pobrać wszystkie dokumenty z bazy danych, która jest zdalnie przechowywana na serwerze (CouchDB).

W tym celu zamiast nazwy bazy danych należy podać ścieżkę do bazy danych w CouchDB, w której znajduje się dokument przeznaczony do odczytania.

Przykład

Poniżej znajduje się przykład odczytu wszystkich dokumentów, które istnieją w bazie danych o nazwie my_database który jest przechowywany na serwerze CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Zapisz powyższy kod w pliku o nazwie Remote_Read_AllDocument.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remote_Read_AllDocument.js

Odczytuje zawartość podanego dokumentu, który istnieje w nazwie bazy danych my_database który jest przechowywany w CouchDB i wyświetlany na konsoli, jak pokazano poniżej.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '3-552920d1ca372986fad7b996ce365f5d' },
      doc: { 
         _id: '001',
         _rev: '3-552920d1ca372986fad7b996ce365f5d',
         name: 'Raju',
         age: 23,
         designation: 'Designer' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-9af15cb11054ebe03a7816bf6c5e4128' },
      doc: { 
         _id: '002',
         _rev: '1-9af15cb11054ebe03a7816bf6c5e4128',
         name: 'Robert',
         age: 24,
         Designation: 'Programmer' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-3033b5a78e915c52fd37325d42eb3935' },
      doc: { 
         _id: '003',
         _rev: '1-3033b5a78e915c52fd37325d42eb3935',
         name: 'Rahim',
         age: 25,
         Designation: 'Programmer' 
      } 
   } 
]

Możesz zaktualizować tablicę dokumentów w PouchDB na raz za pomocą bulkDocs()metoda. Aby to zrobić, musisz utworzyć tablicę dokumentów, w których każdy dokument zawiera_id, _rev i wartości, które mają zostać zaktualizowane.

Załóżmy, że baza danych o nazwie my_database który jest przechowywany lokalnie w PouchDB zawiera 3 dokumenty, mianowicie doc1, doc2, doc3 z następującą zawartością.

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

Załóżmy, że musimy zwiększyć wartości wieku we wszystkich 3 dokumentach o 2 lata. Aby tak się stało, najpierw musisz pobrać plik_revwartości. Dlatego pobierz zawartość tych dokumentów przy użyciu następującego kodu.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true},function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Zapisz powyższy kod jako bulk_fetch.js. Podczas wykonywania powyższy program podaje wartości _id i _rev dokumentów w bazie danych, jak pokazano poniżej.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-1604b0c3ff69dc1e261265fd60808404' } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-b5e49db7e984841bf12a13e3ee548125' } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-a7b342786ecc707aa91f3b321a177b51' } 
   } 
]

Teraz możesz zaktualizować dokumenty, używając ich odpowiednich _id i _rev wartości, jak pokazano poniżej.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_databas');

//Preparing the document
docs = [{_id : '001', _rev: '1-1604b0c3ff69dc1e261265fd60808404', age : 25, },
      {_id : '002', _rev: '1-b5e49db7e984841bf12a13e3ee548125', age : 26, },
      {_id : '003', _rev: '1-a7b342786ecc707aa91f3b321a177b51', age : 27 }]

//Updating the documents in bulk
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents Updated Successfully");
   }
});

Zapisz powyższy kod w pliku o nazwie Update_All_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocą node, jak pokazano poniżej.

C:\PouchDB_Examples >node Update_All_Document.js

Spowoduje to zaktualizowanie wszystkich dokumentów znajdujących się w nazwie bazy danych my_database który jest przechowywany lokalnie, wyświetlając następujący komunikat.

Documents Updated Successfully

Teraz, jeśli wykonasz bulk_fetch.js program dodając {include_docs: true} jako parametr do allDocs() funkcji, przed wywołaniem zwrotnym zobaczysz wartości zaktualizowanych dokumentów, jak pokazano poniżej.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '2-77f3a9974dd578d12f3f2a33aae64c8d' },
      doc: { 
         age: 25,
         _id: '001',
         _rev: '2-77f3a9974dd578d12f3f2a33aae64c8d' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '2-43966007568ce9567c96422195fcfa0d' },
      doc: { 
         age: 26,
         _id: '002',
         _rev: '2-43966007568ce9567c96422195fcfa0d' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '2-6c5349652527f4f39583ff14f23cd677' },
      doc: { 
         age: 27,
         _id: '003',
         _rev: '2-6c5349652527f4f39583ff14f23cd677' 
      } 
   } 
]

Aktualizowanie wsadu ze zdalnej bazy danych

Możesz zaktualizować wszystkie dokumenty z bazy danych, która jest zdalnie przechowywana na serwerze (CouchDB).

Aby to zrobić, zamiast nazwy bazy danych należy podać ścieżkę do bazy danych w CouchDB, w której znajduje się dokument przeznaczony do odczytania.

Przykład

I załóżmy, że wybierzemy bazę danych o nazwie my_database, możesz zauważyć, że zawiera 3 dokumenty, jak pokazano na poniższym zrzucie ekranu.

Teraz pobierz zawartość tych dokumentów, korzystając z następującego kodu.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Zapisz powyższy kod jako remote_bulk_fetch.js. Podczas wykonywania powyższy program podaje zawartość wszystkich dokumentów w bazie danych, jak pokazano poniżej.

[ 
   { 
      id: '001', 
      key: '001', 
      value: { rev: '3-552920d1ca372986fad7b996ce365f5d' }, 
      doc: { 
         _id: '001', 
         _rev: '3-552920d1ca372986fad7b996ce365f5d', 
         name: 'Raju', 
         age: 23, 
         designation: 'Designer' 
      } 
   },
   { 
      id: '002', 
      key: '002', 
      value: { rev: '1-9af15cb11054ebe03a7816bf6c5e4128' }, 
      doc: { 
         _id: '002', 
         _rev: '1-9af15cb11054ebe03a7816bf6c5e4128', 
         name: 'Robert', 
         age: 24, 
         Designation: 'Programmer' 
      } 
   }, 
   { 
      id: '003', 
      key: '003', 
      value: { rev: '1-3033b5a78e915c52fd37325d42eb3935' }, 
      doc: { 
         _id: '003',
         _rev: '1-3033b5a78e915c52fd37325d42eb3935',
         name: 'Rahim', 
         age: 25, 
         Designation: 'Programmer' 
      } 
   } 
]

Poniżej znajduje się przykład aktualizacji wszystkich dokumentów, które istnieją w bazie danych o nazwie my_database który jest przechowywany na serwerze CouchDB.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object 
var db = new PouchDB('http://localhost:5984/my_database'); 

//Preparing the document 
docs = [{_id : '001', _rev: '3-552920d1ca372986fad7b996ce365f5d', age : 24, }, 
      {_id : '002', _rev: '1-9af15cb11054ebe03a7816bf6c5e4128', age : 26, }, 
      {_id : '003', _rev: '1-3033b5a78e915c52fd37325d42eb3935', age : 27}]

//Inserting Document 
db.bulkDocs(docs, function(err, response) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(+"Documents Updated Successfully"); 
   } 
});

Zapisz powyższy kod w pliku o nazwie Remote_Update_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocą node, jak pokazano poniżej.

C:\PouchDB_Examples >node Remote_Update_Document.js

Spowoduje to zaktualizowanie zawartości wszystkich podanych dokumentów, które istnieją w nazwie bazy danych my_database który jest przechowywany w CouchDB i wyświetla następujący komunikat.

Documents Updated Successfully

Teraz, jeśli wykonasz remote_bulk_fetch.js program zobaczysz wartości zaktualizowanych dokumentów, jak pokazano poniżej.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '4-6bc8d9c7a60fed2ed1667ec0740c1f39' },
      doc: { 
         _id: '001',
         _rev: '4-6bc8d9c7a60fed2ed1667ec0740c1f39',
         age: 25 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '2-1aa24ce77d96bb9d2a0675cdf1e113e0' },
      doc: { 
         _id: '002',
         _rev: '2-1aa24ce77d96bb9d2a0675cdf1e113e0',
         age: 26 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '2-fa113149ba618eda77f73072974a2bc1' },
      doc: { 
         _id: '003',
         _rev: '2-fa113149ba618eda77f73072974a2bc1',
         age: 27 
      } 
   } 
]

Możesz usunąć tablicę dokumentów w PouchDB na raz za pomocą bulkDocs()metoda. Aby to zrobić, musisz utworzyć tablicę dokumentów, które mają zostać usunięte, gdzie każdy dokument powinien zawierać_id i _rev. Oprócz tego musisz dodać kolejną parę klucz-wartość_deleted: true.

Załóżmy, że baza danych o nazwie my_database który jest przechowywany lokalnie w PouchDB zawiera 3 dokumenty, mianowicie doc1, doc2, doc3 z następującą zawartością.

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'}
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

Powiedzmy, że musimy usunąć wszystkie trzy dokumenty. Następnie przede wszystkim musisz zdobyć ich_revwartości. Dlatego pobierz zawartość tych dokumentów przy użyciu następującego kodu.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true},function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Zapisz powyższy kod jako bulk_fetch.js. Wykonanie powyższego programu daje wartości _id i _rev dokumentów w bazie danych, jak pokazano poniżej.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-1604b0c3ff69dc1e261265fd60808404' } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-b5e49db7e984841bf12a13e3ee548125' } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-a7b342786ecc707aa91f3b321a177b51' } 
   } 
]

Teraz możesz usunąć dokumenty, używając ich odpowiednich _id i _rev wartości, jak pokazano poniżej.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing the document
docs = [{_id : '001', _rev: '2-77f3a9974dd578d12f3f2a33aae64c8d', _deleted : true },
      {_id : '002', _rev: '2-43966007568ce9567c96422195fcfa0d', _deleted : true }, 
      {_id : '003', _rev: '2-6c5349652527f4f39583ff14f23cd677',_deleted : true }]

//Deleting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log(response+"Documents deleted Successfully");
   }
});

Zapisz powyższy kod w pliku o nazwie Delete_All_Document.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocą node, jak pokazano poniżej.

C:\PouchDB_Examples >node Delete_All_Document.js

Spowoduje to usunięcie wszystkich dokumentów znajdujących się w wymienionej bazie danych my_database który jest przechowywany lokalnie, wyświetlając następujący komunikat.

Documents Deleted Successfully

Teraz, jeśli wykonasz bulk_fetch.js program, możesz zaobserwować pusty nawias klamrowy na konsoli wskazujący, że baza danych jest pusta, jak pokazano poniżej.

[]

Usuwanie wsadu ze zdalnej bazy danych

Możesz zaktualizować wszystkie dokumenty z bazy danych, która jest zdalnie przechowywana na serwerze (CouchDB).

Aby to zrobić, zamiast nazwy bazy danych należy podać ścieżkę do bazy danych w CouchDB, w której znajduje się dokument przeznaczony do odczytania.

Przykład

Jeśli wybierzemy bazę danych o nazwie my_database, możesz zauważyć, że zawiera 3 dokumenty, jak pokazano na poniższym zrzucie ekranu.

Poniżej znajduje się przykład usunięcia wszystkich dokumentów, które istnieją w bazie danych o nazwie my_database który jest przechowywany na serwerze CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Preparing the document
docs = [{_id : '001', _rev: '4-6bc8d9c7a60fed2ed1667ec0740c1f39', _deleted : true },
      {_id : '002', _rev: '2-1aa24ce77d96bb9d2a0675cdf1e113e0', _deleted : true },
      {_id : '003', _rev: '2-fa113149ba618eda77f73072974a2bc1',_deleted : true }]

//Deleting Documents
db.bulkDocs(docs, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log("Documents deleted Successfully");
   }
});

Zapisz powyższy kod w pliku o nazwie Remote_delete_AllDocuments.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocą node, jak pokazano poniżej.

C:\PouchDB_Examples >node Remote_Delete_AllDocuments.js

Spowoduje to usunięcie zawartości całego podanego dokumentu, który istnieje w wymienionej bazie danych my_database który jest przechowywany w CouchDB i wyświetla następujący komunikat.

Documents Deleted Successfully

Możesz dołączyć obiekt binarny do dokumentu za pomocą rozszerzenia putAttachment() metoda w PouchDB.

Składnia

Poniżej znajduje się składnia putAttachment(). Do tej metody wraz z załącznikiem musimy przekazać id dokumentu, id załącznika, typ MIME. Ta metoda akceptuje również opcjonalną funkcję zwrotną.

db.putAttachment( docId, attachmentId, attachment, type, [callback] );

Możemy przygotować załącznik za pomocą obiektów typu blob lub buffer, gdzie blob jest używany podczas pracy z przeglądarką i buffer jest używany podczas pracy z Node.jsponieważ demonstrujemy nasze programy w Node.js, używamy obiektów buforowych do przygotowywania dokumentów.

Przykład

Poniżej znajduje się przykład tworzenia dokumentu z załącznikiem w bazie danych o nazwie my_database w PouchDB za pomocą putAttachment() metoda.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object var db = new PouchDB('my_database');

//Preparing the attachment 
var my_attachment = new Buffer(['Welcome to tutorialspoint'], {type: 'text/plain'});

//Adding attachment to a document 
db.putAttachment('001', 'att_1.txt', my_attachment, 'text/plain', function(err, res) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(res+"Attachment added successfully") 
   } 
});

Zapisz powyższy kod w pliku o nazwie Add_Attachment.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Add_Attachment.js

Spowoduje to utworzenie pustego dokumentu i dodanie do niego załącznika w bazie danych o nazwie my_database który jest przechowywany w PouchDB i wyświetla następujący komunikat.

Attachment added successfully

Możesz sprawdzić, czy załącznik został dodany, czytając dokument przy użyciu następującego kodu.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object var db = new PouchDB('my_database');

//Reading the Document 
db.get('001',{attachments: true}, function(err, doc) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(doc); 
   } 
});

Zapisz powyższy kod jako read_doc.jsi wykonaj to. Uruchamiając ten program, możesz zobaczyć następującą zawartość dokumentu.

{ 
   _attachments: { 
      att_1.txt: { 
         content_type: 'text/plain',
         digest: 'md5-k7iFrf4NoInN9jSQT9WfcQ==',
         data: 'AA==' 
      } 
   },
   _id: '001',
   _rev: '1-620fd5f41d3328fcbf9ce7504338a51d' 
}

Dodawanie załącznika do istniejącego dokumentu

Załóżmy, że w bazie danych znajduje się dokument o nazwie my_database PouchDB z identyfikatorem002”. Możesz pobrać jego zawartość, wykonując plikread_doc.js zmieniając wartość id na 002, jak pokazano niżej.

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _id: '002',
   _rev: '1-05ca7b5f3f4762a9fb2d119cd34c8d40' 
}

Teraz możesz dodać załącznik do tego dokumentu, używając jego _rev wartość.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object var db = new PouchDB('my_database');

//Adding attachment to existing document 
var my_attachment = new Buffer (['Welcome to tutorialspoint'], {type: 'text/plain'});

rev = '1-05ca7b5f3f4762a9fb2d119cd34c8d40'; 
db.putAttachment('002', 'att_1.txt', rev, my_attachment, 'text/plain', function(err, res) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log (res + "Attachment added successfully") 
   } 
});

Zapisz powyższy kod w pliku o nazwie Add_Attachment_to_doc.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Add_Attachment_to_doc.js

Spowoduje to dodanie załącznika do określonego dokumentu, wyświetlającego następującą wiadomość.

Attachment added successfully

Jeśli zmienisz wartość id w read_doc.js do 002 i uruchom go, otrzymasz następujący wynik.

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _attachments: { 
      att_1: { 
         content_type: 'text/plain',
         digest: 'md5-k7iFrf4NoInN9jSQT9WfcQ==',
         data: 'AA==' 
      } 
   },
   _id: '002',
   _rev: '2-3bb4891b954699bce28346723cc7a709' 
}

Dodawanie załącznika do zdalnego dokumentu

Możesz nawet dodać załącznik do dokumentu istniejącego w bazie danych, która jest przechowywana zdalnie na serwerze (CouchDB).

Aby to zrobić, zamiast nazwy bazy danych należy podać ścieżkę do bazy danych w CouchDB, w której znajduje się dokument przeznaczony do odczytania.

Przykład

A jeśli wybierzesz bazę danych o nazwie my_database, możesz wyświetlić jego zawartość, jak pokazano poniżej.

Poniżej znajduje się przykład dodawania załącznika do dokumentu 001 przechowywane w bazie danych o nazwie my_database który jest przechowywany na serwerze CouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('http://localhost:5984/my_database');

//Adding attachment to existing document
var my_attachment = new Buffer (['Welcome to tutorialspoint'], {type: 'text/plain'});

rev = '1-36c34fdcf29a652876219065f9681602';
db.putAttachment('001', 'att_1.txt',rev, my_attachment, 'text/plain', function(err, res) {
   if (err) {
      return console.log(err);
   } else {
      console.log (res+ "Attachment added successfully")
   }
});

Zapisz powyższy kod w pliku o nazwie Remote_Add_Attachment.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remote_Add_Attachment.js

Spowoduje to dodanie załącznika do określonego dokumentu, wyświetlającego następującą wiadomość.

Attachment added successfully

Teraz, jeśli zweryfikujesz dokument, możesz obserwować załącznik do niego dodany, jak pokazano na poniższym zrzucie ekranu.

Możesz pobrać załącznik z PouchDB za pomocą getAttachment()metoda. Ta metoda zawsze zwraca obiekty typu blob lub bufory.

Składnia

Poniżej znajduje się składnia getAttachment(). Do tej metody musimy przekazać id dokumentu i id załącznika. Ta metoda akceptuje również opcjonalną funkcję zwrotną.

db.getAttachment( docId, attachmentId, [callback] );

Przykład

Poniżej znajduje się przykład pobierania załącznika do dokumentu przechowywanego w PouchDB przy użyciu getAttachment()metoda. Korzystając z tego kodu, próbujemy pobrać załącznikatt_1.txt z dokumentu 001.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Retrieving an attachment from a document
db.getAttachment('001', 'att_1.txt', function(err, blob_buffer) {
   if (err) {
      return console.log(err);
   } else {
      console.log(blob_buffer);
   }
});

Zapisz powyższy kod w pliku o nazwie Retrieve_Attachment.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Retrieve_Attachment.js

Spowoduje to pobranie załącznika dokumentu i wyświetlenie go na konsoli, jak pokazano poniżej.

<Buffer 00>

Pobieranie załącznika z dokumentu zdalnego

Możesz także pobrać załącznik do dokumentu istniejącego w bazie danych, który jest przechowywany zdalnie na serwerze (CouchDB).

Aby to zrobić, zamiast nazwy bazy danych należy podać ścieżkę do bazy danych w CouchDB, w której znajduje się dokument przeznaczony do odczytania.

Przykład

Jeśli wybierzesz bazę danych o nazwie my_database, możesz wyświetlić jego zawartość, jak pokazano poniżej.

Załóżmy, że w tym dokumencie znajduje się załącznik, jak pokazano poniżej.

Poniżej znajduje się przykład pobierania załącznika do dokumentu 001 który istnieje w bazie danych o nazwie my_database, który jest przechowywany na serwerze CouchDB.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object 
var db = new PouchDB('http://localhost:5984/my_database');

//Retrieving an attachment from a document 
db.getAttachment('001', 'att_1.txt', function(err, blob_buffer) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(blob_buffer); 
   } 
});

Zapisz powyższy kod w pliku o nazwie Remote_Retrieve_Attachment.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remote_Retrieve_Attachment.js

Spowoduje to pobranie załącznika dokumentu i wyświetlenie go na konsoli, jak pokazano poniżej.

<Buffer 00>

Możesz usunąć załącznik z PouchDB za pomocą removeAttachment() metoda.

Składnia

Poniżej znajduje się składnia removeAttachment()metoda. Do tej metody musimy przekazać identyfikator dokumentu, identyfikator załącznika i wartość _rev. Ta metoda akceptuje również opcjonalną funkcję zwrotną.

db.removeAttachment ( docId, attachmentId, rev, [callback] );

Przykład

Załóżmy, że w PouchDB znajduje się dokument o identyfikatorze 001, który zawiera identyfikator, imię i nazwisko, wiek, oznaczenie pracownika wraz z załącznikiem, jak pokazano poniżej.

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _attachments: { 
      'att_1.txt': { 
         content_type: 'text/plain',
         digest: 'md5-k7iFrf4NoInN9jSQT9WfcQ==',
         data: 'AA==' 
      } 
   },
   _id: '001',
   _rev: '2-cdec6c9f45ddbee7d456945654742d43' 
}

Poniżej znajduje się przykład usuwania załącznika tego dokumentu 001 przechowywane w PouchDB przy użyciu removeAttachment() metoda.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my');
db.removeAttachment('001', 'att_1.txt', '2-cdec6c9f45ddbee7d456945654742d43', 
   function(err, res) {
   if (err) {
      return console.log(err);
   } else {
      console.log(res+"Attachment Deleted successfully")
   }
});

Zapisz powyższy kod w pliku o nazwie Remove_Attachment.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remove_Attachment.js

Spowoduje to usunięcie załącznika dokumentu i wyświetlenie komunikatu na konsoli, jak pokazano poniżej.

Attachment deleted successfully

Po usunięciu możesz zweryfikować zawartość dokumentu, wykonując następujący kod.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_d');

//Reading the Document
db.get('001',{attachments: true}, function(err, doc) {
   if (err) {
      return console.log(err);
   } else {
      console.log(doc);
   }
});

Zapisz ten kod jako read.jsi wykonaj to. Podczas wykonywania otrzymasz zawartość dokumentu po usunięciu załącznika, jak pokazano poniżej.

{ 
   name: 'Raju',
   age: 23,
   designation: 'Designer',
   _id: '001',
   _rev: '3-da775487a6ed0495f2e49c543384f8e8' 
}

Usuwanie załącznika ze zdalnego dokumentu

Możesz usunąć załącznik z istniejącego dokumentu w bazie danych, który jest przechowywany zdalnie na serwerze (CouchDB).

Aby to zrobić, zamiast nazwy bazy danych należy podać ścieżkę do bazy danych w CouchDB, w której znajduje się dokument przeznaczony do odczytania.

Przykład

A jeśli wybierzesz bazę danych o nazwie my_database, możesz wyświetlić jego zawartość, jak pokazano poniżej.

Załóżmy, że w tym dokumencie znajduje się załącznik, jak pokazano poniżej.

Poniżej znajduje się przykład usunięcia wyżej wymienionego załącznika dokumentu 001 który istnieje w bazie danych o nazwie my_database który jest przechowywany na serwerze CouchDB.

//Requiring the package 
var PouchDB = require('PouchDB');

//Creating the database object 
var db = new PouchDB('http://localhost:5984/my_database');

db.removeAttachment('001', 'att_1.txt', '2-049f1c4ffa54576ec0947b65e34de423', 
   function(err, res) { 
   if (err) { 
      return console.log(err); 
   } else { 
      console.log(res+"Attachment Deleted successfully") 
   } 
});

Zapisz powyższy kod w pliku o nazwie Remote_Delete_Attachment.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Remote_Delete_Attachment.js

Spowoduje to usunięcie istniejącego załącznika i wyświetlenie następującego komunikatu.

Attachment Deleted successfully

Jeśli ponownie odwiedzisz dokument, możesz zauważyć, że załącznik został usunięty, jak pokazano na poniższym zrzucie ekranu.

Jedną z najważniejszych funkcji PouchDB jest replikacja, czyli można wykonać kopię bazy danych. Możesz replikować instancję PouchDB przechowywaną lokalnie lub instancję CouchDB przechowywaną zdalnie.

Składnia

Poniżej przedstawiono składnię replikowania bazy danych w PouchDB. Tutaj kopiasource databasejest celem. Do tej metody można bezpośrednio przekazać lokalizację źródłowych i docelowych baz danych w formacie String lub można przekazać reprezentujące je obiekty.

PouchDB.replicate(source, target, [options])

Zarówno źródło, jak i cele mogą być instancjami PouchDB lub CouchDB.

Replikowanie LocalDB do CouchDB

Załóżmy, że istnieje baza danych o nazwie sample_database w PouchDB i zawiera 3 dokumenty doc1, doc2 i doc3, których zawartość jest pokazana poniżej.

doc1 = {_id: '001', name: 'Ram', age: 23, Designation: 'Programmer'} 
doc2 = {_id: '002', name: 'Robert', age: 24, Designation: 'Programmer'} 
doc3 = {_id: '003', name: 'Rahim', age: 25, Designation: 'Programmer'}

Poniżej znajduje się przykład, który tworzy kopię bazy danych o nazwie sample_database który jest przechowywany lokalnie w CouchDB.

//Requiring the package 
var PouchDB = require('PouchDB');

var localdb = 'sample_database';

//Creating remote database object 
var remotedb = 'http://localhost:5984/sample_database';

//Replicating a local database to Remote 
PouchDB.replicate(localDB, remoteDB); 
console.log ("Database replicated successfully");

Zapisz powyższy kod w pliku o nazwie Replication_example.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Replication_example.js

Spowoduje to utworzenie kopii bazy danych o nazwie sample_database w instancji CouchDB i wyświetlenie komunikatu na konsoli, jak pokazano poniżej.

Database replicated successfully

Możesz sprawdzić, czy baza danych jest replikowana w Twojej instancji CouchDB, klikając poniższe łącze http://127.0.0.1:5984/_utils/index.html.

Po kliknięciu możesz zobaczyć listę baz danych w swojej CouchDB. Można również zauważyć, że kopia bazy danychsample_database powstaje tutaj.

Jeśli wybierzesz zreplikowaną bazę danych, możesz wyświetlić jej zawartość, jak pokazano poniżej.

Replikacja CouchDB do PouchDB

Załóżmy, że istnieje baza danych o nazwie Remote_Database w CouchDB i zawiera 3 dokumenty, doc1, doc2 i doc3, o zawartości pokazanej poniżej.

doc1 = {_id: '001', name: 'Geeta', age: 25, Designation: 'Programmer'}
doc2 = {_id: '002', name: 'Zara Ali', age: 24, Designation: 'Manager'}
doc3 = {_id: '003', name: 'Mary', age: 23, Designation: 'Admin'}

Poniżej znajduje się przykład, który tworzy kopię bazy danych o nazwie Remote_Database który jest przechowywany w CouchDB w pamięci lokalnej.

//Requiring the package
var PouchDB = require('PouchDB');

var localdb = 'sample_database';

var remotedb = 'http://localhost:5984/sample_database1';

//Replicating a local database to Remote
PouchDB.replicate(remotedb, localdb);
console.log("Database replicated successfully");

Zapisz powyższy kod w pliku o nazwie Replication_example2.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Replication_example2.js

Spowoduje to utworzenie kopii bazy danych o nazwie remote_database w instancji PouchDB i wyświetla komunikat na konsoli, jak pokazano poniżej.

Database replicated successfully

Możesz sprawdzić, czy baza danych jest replikowana w Twojej instancji Pouch, wykonując następujący kod.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('remote_database');

//Retrieving all the documents in PouchDB
db.allDocs({include_docs: true, attachments: true}, function(err, docs) {
   if (err) {
      return console.log(err);
   } else {
      console.log(docs.rows);
   }
});

Jeśli baza danych jest replikowana podczas wykonywania powyższego kodu, otrzymasz zawartość replikowanej bazy danych, jak pokazano poniżej.

[ 
   { 
      id: '001', 
      key: '001', 
      value: { rev: '1-23cf3767e32a682c247053b16caecedb' }, 
      doc: { 
         name: 'Geeta', 
         age: 25, 
         Designation: 'Programmer', 
         _id: '001',
         _rev: '1-23cf3767e32a682c247053b16caecedb' 
      } 
   }, 
   { 
      id: '002', 
      key: '002', 
      value: { rev: '1-d5bcfafbd4d4fae92fd7fc4fdcaa3a79' }, 
      doc: { 
         name: 'Zara Ali', 
         age: 24, 
         Designation: 'Manager', 
         _id: '002',
         _rev: '1-d5bcfafbd4d4fae92fd7fc4fdcaa3a79' 
      } 
   }, 
   { 
      id: '003', 
      key: '003', 
      value: { rev: '1-c4cce025dbd30d21e40882d41842d5a4' }, 
      doc: { 
         name: 'Mary', 
         age: 23, 
         Designation: 'Admin', 
         _id: '003', 
         _rev: '1-c4cce025dbd30d21e40882d41842d5a4' 
      } 
   } 
]

Możesz synchronizować bazy danych przechowywane lokalnie w PouchDB z bazami przechowywanymi w CouchDB. W poprzednim rozdziale widzieliśmy, jak replikować bazy danych za pomocą PouchDB. Tam zastosowaliśmy metodęPouchDB.replicate(source, destination).

Oprócz tego możemy również replikować dane z lokalnej bazy danych do zdalnej bazy danych oraz ze zdalnej bazy danych do lokalnej bazy danych za pomocą replicate.to() i replicate.from() metody, jak pokazano poniżej.

//Replicating data from local database to remote database 
localDB.replicate.to(remoteDB);

//Replicating data from remote database to local database 
localDB.replicate.from(remoteDB);

Gdzie, localDB jest obiektem bazy danych przechowywanym lokalnie w PouchDB i remoteDB to obiekt bazy danych przechowywany w CouchDB.

Przykład

Załóżmy, że istnieje baza danych o nazwie local_database w PouchDB i zawiera 3 dokumenty, doc1, doc2 i doc3, o zawartości pokazanej poniżej.

doc1 = {_id: '003', name: 'Ram', age: 26, Designation: 'Programmer'} 
doc2 = {_id: '004', name: 'Robert', age: 27, Designation: 'Programmer'} 
doc3 = {_id: '005', name: 'Rahim', age: 28, Designation: 'Programmer'}

Jest też baza danych o nazwie Remote_Database w CouchDB i zawiera 2 dokumenty doc1, doc2 o zawartości pokazanej poniżej.

doc1 = {_id: '001', name: 'Geeta', age: 25, Designation: 'Programmer'} 
doc2 = {_id: '002', name: 'Zara Ali', age: 24, Designation: 'Manager'}

Poniżej znajduje się przykład synchronizacji tych dwóch baz danych, gdzie jedna jest przechowywana w PouchDB, a druga w CouchDB, przy użyciu replicate.to() i replicate.from() metody.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating local database object
var localDB = new PouchDB('local_database');

//Creating remote database object
var remoteDB = new PouchDB('http://localhost:5984/remote_database');

//Synchronising both databases
localDB.replicate.to(remoteDB);
remoteDB.replicate.from(localDB);
console.log("Databases synchronized successfully");

Zapisz powyższy kod w pliku o nazwie Synchronising_databases.js. Otwórz wiersz polecenia i uruchom plik JavaScript za pomocąnode jak pokazano niżej.

C:\PouchDB_Examples >node Synchronising_databases.js

Spowoduje to synchronizację dwóch baz danych remoteDB i localDB oraz wyświetlenie komunikatu na konsoli, jak pokazano poniżej.

Databases synchronized successfully.

Po zsynchronizowaniu dwóch baz danych odwiedź witrynę http://127.0.0.1:5984/_utils/index.html i wybierz plik remote_database. Można zauważyć, że dokumenty z lokalnej bazy danych (003, 004, 005) zostały skopiowane do tej bazy danych, jak pokazano poniżej.

W ten sam sposób, jeśli pobierzesz zawartość pliku local_database przechowywane w PouchDB można zobaczyć, że dokumenty bazy danych, która jest przechowywana w CouchDB, zostały tutaj skopiowane.

[ 
   { 
      id: '001',
      key: '001',
      value: { rev: '1-23cf3767e32a682c247053b16caecedb' },
      doc: { 
         name: 'Geeta',
         age: 25,
         Designation: 'Programmer',
         _id: '001',
         _rev: '1-23cf3767e32a682c247053b16caecedb' 
      } 
   },
   { 
      id: '002',
      key: '002',
      value: { rev: '1-d5bcfafbd4d4fae92fd7fc4fdcaa3a79' },
      doc: { 
         name: 'Zara Ali',
         age: 24,
         Designation: 'Manager',
         _id: '002',
         _rev: '1-d5bcfafbd4d4fae92fd7fc4fdcaa3a79' 
      } 
   },
   { 
      id: '003',
      key: '003',
      value: { rev: '1-bf4619471ac346fdde46cfa8fbf3587f' },
      doc: { 
         name: 'Ram',
         age: 26,
         Designation: 'Programmer',
         _id: '003',
         _rev: '1-bf4619471ac346fdde46cfa8fbf3587f' 
      } 
   },
   { 
      id: '004',
      key: '004',
      value: { rev: '1-29b8f803958c994e3eb37912a45d869c' },
      doc: { 
         name: 'Robert',
         age: 27,
         Designation: 'Programmer',
         _id: '004',
         _rev: '1-29b8f803958c994e3eb37912a45d869c' 
      } 
   },
   { 
      id: '005',
      key: '005',
      value: { rev: '1-0eb89f71998ffa8430a640fdb081abd2' },
      doc: { 
         name: 'Rahim',
         age: 28,
         Designation: 'Programmer',
         _id: '005',
         _rev: '1-0eb89f71998ffa8430a640fdb081abd2' 
      } 
   } 
]

Możesz przepisać powyższy program za pomocą rozszerzenia sync() metoda udostępniana przez PouchDB zamiast dwóch metod replicate.to() i replicate.from() jak pokazano niżej.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating local database object
var localDB = new PouchDB('local');

//Creating remote database object
var remoteDB = new PouchDB('http://localhost:5984/remote_database');

//Synchronising Remote and local databases
localDB.sync(remoteDB, function(err, response) {
   if (err) {
      return console.log(err);
   } else {
      console.log(response);
   }
});

Wykonując powyższy program, synchronizuje dwie bazy danych wyświetlając następujący komunikat.

{ 
   push: { 
      ok: true,
      start_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time),
      docs_read: 6,
      docs_written: 6,
      doc_write_failures: 0,
      errors: [],
      last_seq: 10,
      status: 'complete',
      end_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time) 
   },
   pull: { 
      ok: true,
      start_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time),
      docs_read: 0,
      docs_written: 0,
      doc_write_failures: 0,
      errors: [],
      last_seq: 2,
      status: 'complete',
      end_time: Fri Mar 25 2016 15:54:37 GMT+0530 (India Standard Time) 
   } 
}

W tym rozdziale omówimy takie pojęcia, jak kompresja i pobieranie danych zbiorczych z PouchDB.

Zagęszczanie

Możesz zmniejszyć rozmiar bazy danych, usuwając nieużywane dane za pomocą compact()metoda. Za pomocą tej metody można kompaktować lokalną bazę danych, a także zdalną bazę danych.

Poniżej znajduje się przykład demonstrujący użycie compact() metoda w PouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('sample_database');

db.compact(function (err, result) {
   if (err) {
      return console.log(err);
   } else {
      console.log(result);
   }
});

Metoda BulkGet

Możesz zbiorczo pobrać zestaw dokumentów za pomocą rozszerzenia bulkGet()metoda. Do tej metody musisz przekazać zestaw id i _rev.

Poniżej znajduje się przykład demonstrujący użycie bulkGet() metoda w PouchDB.

//Requiring the package
var PouchDB = require('PouchDB');

//Creating the database object
var db = new PouchDB('my_database');

//Preparing documents
//Inserting Document
db.bulkGet({docs: [
   { id: "001", rev: "1-5dc593eda0e215c806677df1d12d5c47"},
   { id: "002", rev: "1-2bfad8a9e66d2679b99c0cab24bd9cc8"},
   { id: "003", rev: "1-7cff4a5da1f97b077a909ff67bd5b047"} ]}, function(err, result) {
   if (err) {
      return console.log(err);
   } else {
      console.log(result);
   }
});