PouchDB - Guia Rápido

Este capítulo fornece uma breve introdução ao PouchDB, juntamente com seus recursos e como ele funciona.

O que é PouchDB?

PouchDB é um código aberto in-browser database APIescrito em JavaScript. É modelado após Couch DB & minuss; um banco de dados NoSQL. Usando esta API, podemos construir aplicativos que funcionam offline e online. Ele usa internamente WebSQL e IndexedDB para armazenar dados.

Como funciona?

No PouchDB, quando o aplicativo está offline, os dados são armazenados localmente usando WebSQL e IndexedDB no navegador. Quando o aplicativo está online novamente, ele é sincronizado com o CouchDB e servidores compatíveis.

Usando o PouchDB, você pode se comunicar com bancos de dados locais e remotos perfeitamente sem notar nenhuma diferença.

Recursos do PouchDB

A seguir estão os recursos do PouchDB -

Cross Browser - A API fornecida pelo PouchDB funciona da mesma forma em todos os ambientes, portanto, podemos executar um aplicativo PouchDB em vários navegadores.
Light Weight - PouchDB é uma API muito leve, também é incluída facilmente usando apenas uma tag de script.
Easy to Learn - Se você tem um conhecimento prévio de qualquer linguagem de programação, é fácil aprender PouchDB.
Open Source - PouchDB é um aplicativo de código aberto e está disponível no GitHub.

Vantagens do PouchDB

A seguir estão as vantagens do PouchDB -

Como o PouchDB reside dentro do navegador, não há necessidade de realizar consultas na rede, o que resulta em uma execução mais rápida das consultas.
Você pode sincronizar os dados com qualquer um dos servidores suportados e, ao fazer isso, você pode executar aplicativos online e offline.

Navegadores que suportam PouchDB

A seguir estão os navegadores que suportam PouchDB -

Firefox 29+ (incluindo Firefox OS e Firefox para Android)
Chrome 30+
Safari 5+
Internet Explorer 10+
Opera 21+
Android 4.0+
iOS 7.1+
Windows Phone 8+

Este capítulo explica como baixar e instalar o PouchDB em seu sistema.

Instalando PouchDB

Para trabalhar com o PouchDB, você precisa baixar o arquivo .jsarquivo e inclua-o em seu script. A seguir estão as etapas para instalar o PouchDB.

Passo 1

Visite a página inicial do site do PouchDB, clicando no seguinte link -

https://PouchDB.com/

Passo 2

Clique no botão Download no lado superior direito da página da web, conforme mostrado na captura de tela acima. Isso vai baixarPouchDB-5.3.0.min.js em seu sistema.

etapa 3

Copie e cole o PouchDB-5.3.0.min.js ao seu diretório de trabalho e inclua-o em seu JavaScript, conforme mostrado no comando a seguir.

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

Instalando o Pouch usando Node.js

Você também pode instalar o PouchDB como módulo Node.js. A seguir estão as etapas para instalar o PouchDB usando Node.js.

Passo 1

Instale o Node.js seguindo as etapas fornecidas na seção Instalando o Node.js do nosso tutorial de script de café .

Passo 2

Abra o prompt de comando e execute o seguinte comando. Isso instalará o módulo de nó PouchDB em seu sistema.

npm install --save PouchDB

Baixando CouchDB

Quando offline, o PouchDB armazena dados localmente e funciona como um aplicativo. Você pode acessá-lo online conectando-se a servidores compatíveis. Como sabemos, o PouchDB pode ser conectado ao CouchDB, portanto, vamos instalar o CouchDB também. A seguir estão as etapas para instalar o CouchDB.

Passo 1

O site oficial do CouchDB é http://couchdb.apache.org. Se você clicar no link fornecido, poderá obter a página inicial do site oficial do CouchDB, conforme mostrado na captura de tela a seguir.

Passo 2

Se você clicar no botão de download, isso levará a uma página onde os links de download do CouchDB em vários formatos são fornecidos. O instantâneo a seguir ilustra o mesmo.

etapa 3

Escolha o link de download para sistemas Windows e selecione um dos mirrors fornecidos para iniciar o download.

Instalando CouchDB

Um executável do Windows setup-couchdb-1.6.1_R16B02.exearquivo será baixado em seu sistema. Execute o arquivo de instalação e prossiga com a instalação.

Depois de instalar o CouchDB em seu sistema com sucesso, abra a pasta onde o CouchDB foi instalado, vá para a pasta bin e inicie o servidor executando um arquivo de script denominado couchdb.bat.

Após a instalação, abra a interface da web integrada do CouchDB visitando o seguinte link - http://127.0.0.1:5984/. Se tudo correr bem, você verá uma página da web com a seguinte saída.

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

Você pode interagir com a interface da web do CouchDB usando a seguinte URL -

http://127.0.0.1:5984/_utils/

Isso mostra a página de índice do Futon, que é a interface da web do CouchDB.

Você pode criar um banco de dados no PouchDB usando o construtor PouchDB.

Sintaxe

A seguir está a sintaxe de uso do construtor PouchDB. Para isso, você precisa passar o nome do banco de dados como parâmetro.

new PouchDB(Database_name)

Exemplo

Para criar um banco de dados no PouchDB usando node, em primeiro lugar, você precisa exigir o pacote PouchDB usando o require() método e, em seguida, você pode criar um banco de dados conforme mostrado no exemplo a seguir.

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

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

Salve o código acima em um arquivo com o nome Create_Database.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples>node Create_Database.js

Isso criará um banco de dados localmente (você pode ver a pasta no diretório atual) exibindo a seguinte mensagem.

Database created Successfully.

Você pode obter as informações básicas sobre o banco de dados usando o método chamado info()

Sintaxe

A seguir está a sintaxe de uso do info()método do PouchDB. Este método aceita uma função de retorno de chamada.

db.info([callback])

Exemplo

A seguir está um exemplo de recuperação de informações do banco de dados usando o info()método. Aqui, estamos exibindo as informações do banco de dados denominadomy_database. Em caso de erro, o erro será exibido no console.

//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);
   }
});

Salve o código acima em um arquivo com o nome Database_info.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples>node Database_info.js

Isso exibirá as informações do banco de dados especificado da seguinte maneira.

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

Informações de banco de dados remoto

Da mesma forma, você obtém as informações de um banco de dados que é salvo remotamente no servidor (CouchDB). Para fazer isso, em vez do nome do banco de dados, você precisa passar o caminho para o banco de dados necessário no CouchDB.

Exemplo

A seguir está um exemplo de recuperação de informações de um banco de dados que é salvo no servidor CouchDB. Este código fornece informações de um banco de dados chamadomy_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);
   }
});

Salve o código acima em um arquivo com o nome Database_ Remote_info.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples>node Database_Remote_info.js

Isso exibirá as informações do banco de dados especificado da seguinte maneira.

{ 
   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' 
}

Você pode excluir um banco de dados no PouchDB usando o db.destroy() método.

Sintaxe

A seguir está a sintaxe de uso do db.destroy()método. Este método aceita uma função de retorno de chamada como parâmetro.

db.destroy()

Exemplo

A seguir está um exemplo de exclusão de um banco de dados no PouchDB usando o destroy()método. Aqui, estamos excluindo o banco de dados chamadomy_database, criado nos capítulos anteriores.

//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”);
   }
});

Salve o código acima em um arquivo com o nome Delete_Database.js. Abra o prompt de comando e execute o arquivo JavaScript usando node como mostrado abaixo.

C:\PouchDB_Examples >node Delete_Database.js

Isso irá deletar o banco de dados chamado my_database que é armazenado localmente exibindo a seguinte mensagem.

Database Deleted

Excluindo um Banco de Dados Remoto

Da mesma forma, você pode excluir um banco de dados que está armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados que deve ser excluído, no CouchDB.

Exemplo

Suponha que haja um banco de dados chamado my_databaseno servidor CouchDB. Então, se você verificar a lista de bancos de dados no CouchDB usando o URLhttp://127.0.0.1:5984/_utils/index.html você obterá a seguinte captura de tela.

A seguir está um exemplo de exclusão de um banco de dados denominado my_database que é salvo no servidor 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");
   }
});

Salve o código acima em um arquivo com o nome Remote_Database_Delete.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >Remote_Database_Delete.js

Isso exclui o banco de dados especificado do PouchDB exibindo a seguinte mensagem.

Database Deleted

Verificação

Depois de executar o programa acima, se você visitar o URL novamente, obterá a seguinte captura de tela. Aqui você pode observar apenas dois bancos de dados desdemy_database Foi apagado.

Você pode criar um documento no PouchDB usando o db.put() método.

Sintaxe

A seguir está a sintaxe de uso do método db.put () do PouchDB. Você pode armazenar o documento a ser criado no PouchDB, em uma variável e passar como parâmetro para este método. Além disso, esse método também aceita uma função de retorno de chamada (opcional) como parâmetro.

db.put(document, callback)

Exemplo

A seguir está um exemplo de criação de um documento no PouchDB usando o put()método. O documento que criamos deve estar no formato JSON, um conjunto de pares de valores-chave separados por vírgula (,) e colocado entre chaves ({})

//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");
   }
});

Salve o código acima em um arquivo com o nome Create_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Create_Document.js

Isso cria o documento fornecido no banco de dados PouchDB chamado my_database, que é armazenado localmente, exibindo a seguinte mensagem.

Document created Successfully

Inserindo um documento em um banco de dados remoto

Você também pode inserir um documento no banco de dados que é armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez do nome do banco de dados, você precisa passar o caminho para o banco de dados onde deseja criar documentos no CouchDB.

Exemplo

Agora, se você clicar no banco de dados chamado my_database, você encontrará um banco de dados vazio, conforme mostrado na imagem a seguir.

A seguir está um exemplo de inserção de um documento em um banco de dados denominado my_database que é salvo no servidor 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");
   }
});

Salve o código acima em um arquivo com o nome Remote_Create_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remote_Create_Document.js

Isso cria o documento fornecido no banco de dados PouchDB chamado my_database que é armazenado no CouchDB, exibindo a seguinte mensagem.

Document created Successfully

Verificação

Depois de executar o programa acima, se você visitar o my_database novamente, você pode observar o documento criado conforme mostrado na captura de tela a seguir.

Você pode ler / recuperar o conteúdo de um documento no PouchDB usando o db.get() método.

Sintaxe

A seguir está a sintaxe de uso do db.get()método do PouchDB. Este método aceita odocument id e uma função de retorno de chamada opcional.

db.get(document, callback)

Exemplo

A seguir está um exemplo de leitura do conteúdo de um documento no PouchDB usando o get() método.

//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);
   }
});

Salve o código acima em um arquivo com o nome Read_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usando o nó conforme mostrado abaixo.

C:\PouchDB_Examples >node Read_Document.js

Lê o conteúdo de um determinado documento que existe no banco de dados denominado my_databaseque é armazenado localmente. A mensagem a seguir é exibida no console.

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

Lendo um documento de um banco de dados remoto

Você também pode ler um documento do banco de dados que está armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados no CouchDB, que contém o documento a ser lido.

Exemplo

Ao clicar no banco de dados chamado my_databasevocê pode ver a seguinte captura de tela. Aqui, você pode observar que este banco de dados contém um documento com id001.

A seguir está um exemplo de leitura do conteúdo do documento com id como “001”Que existe em um banco de dados chamado my_database, que é armazenado no servidor 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);
   }
});

Salve o código acima em um arquivo com o nome Remote_Read_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remote_Read_Document.js

Lê o conteúdo de um determinado documento que existe no banco de dados denominado my_databaseque é armazenado no CouchDB. A mensagem a seguir é exibida no console.

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

Sempre que criamos um documento no PouchDB, um novo campo _rev é gerado e é conhecido como revision marker. o_revO valor de é um número aleatório único, cada vez que fazemos alterações no documento, o valor de _rev Mudou.

Você pode atualizar um documento existente no PouchDB usando o (_rev). Para fazer isso, primeiro recupere o_revvalor do documento que queremos atualizar. Agora, coloque o conteúdo que deve ser atualizado junto com o recuperado_rev valor em um novo documento e, finalmente, insira este documento no PouchDB usando o put() método.

Exemplo

Suponha que temos um documento no PouchDB com id 001que tem detalhes de uma pessoa. Para atualizar este documento, devemos ter seu número rev. Portanto, para recuperar o conteúdo do documento, o código a seguir é usado.

//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);
   }
});

Ao executar o código acima, você receberá a seguinte saída.

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

Agora, usando o _rev você pode atualizar o valor da chave “age”A 26, conforme mostrado no código a seguir.

//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);
   }
});

Salve o código acima em um arquivo com o nome Update_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\Pouch_Examples>node Update_Document.js

Isso atualiza o conteúdo de um determinado documento que existe no banco de dados denominado my_databaseque é armazenado localmente. A mensagem a seguir é exibida no console.

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

Atualizando um documento em um banco de dados remoto

Você também pode atualizar um documento existente em um banco de dados armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados no CouchDB, que contém o documento a ser atualizado.

Exemplo

Ao clicar no banco de dados chamado my_database, você pode ver a seguinte captura de tela. Aqui, você pode observar que este banco de dados contém um documento com id001.

A seguir está um exemplo de atualização da idade do documento com id como “001”Que existe em um banco de dados chamado my_database que é armazenado no servidor 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);
   }
});

Salve o código acima em um arquivo com o nome Remote_Update_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remote_Update_Document.js

Isso atualiza o conteúdo de um determinado documento que existe no banco de dados denominado my_databaseque é armazenado no CouchDB. A mensagem a seguir é exibida no console.

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

Você pode excluir um documento de um banco de dados existente no PouchDB usando o db.remove() método.

Sintaxe

A seguir está a sintaxe de uso do db.remove()método do PouchDB. Para este método, temos que passarid e _revpara excluir um documento existente, conforme mostrado no código a seguir. Este método aceita uma função de retorno de chamada opcional. Também podemos passar o documento completo em vez de id e _rev.

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

Exemplo

Suponha que temos um documento no PouchDB com id 001que tem os detalhes de uma pessoa. Para excluir este documento junto com seuid nós também devemos ter o seu _revnúmero. Portanto, recupere o conteúdo do documento conforme mostrado no código a seguir.

//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);
   }
});

Executar o código acima fornece a seguinte saída.

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

Agora, usando o _rev e id do documento, você pode excluí-lo usando o remove() método conforme mostrado no código a seguir.

//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");
   }
});

Salve o código acima em um arquivo com o nome Delete_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Delete_Document.js

Isso exclui o conteúdo de um determinado documento que existe no banco de dados denominado my_databaseque é armazenado localmente. A seguinte mensagem é exibida.

Document deleted successfully

Excluindo um documento de um banco de dados remoto

Você também pode excluir um documento existente do banco de dados que está armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados no CouchDB, que contém o documento a ser lido.

Exemplo

Ao clicar no banco de dados chamado my_databasevocê pode ver a seguinte captura de tela. Aqui, você pode observar que o banco de dados contém um documento com id001.

A seguir está um exemplo de exclusão do conteúdo do documento com id “001”Que existe em um banco de dados chamado my_database que é armazenado no servidor 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");
   }
});

Salve o código acima em um arquivo com o nome Remote_Delete_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remote_Delete_Document.js

Isso exclui o documento fornecido que existe no banco de dados chamado my_databaseque é armazenado no CouchDB. A seguinte mensagem é exibida.

Document deleted successfully

Você pode criar uma matriz (lote) de documentos no PouchDB usando o db.bulkDocs()método. Ao criar documentos, usando este método se não fornecermos valores _id, em nosso nome o PouchDB gera ids exclusivos para todos os documentos em massa.

Sintaxe

A seguir está a sintaxe de uso do db.bulkDocs()método do PouchDB. Você pode armazenar todos os documentos que devem ser criados no PouchDB em um array e passá-lo para este método como um parâmetro. Além disso, esse método também aceita uma função de retorno de chamada (opcional) como parâmetro.

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

Exemplo

A seguir está um exemplo de criação de vários documentos no PouchDB usando o db.bulkDocs ()método. Os documentos que criamos devem estar no formato JSON, um conjunto de pares de valores-chave separados por vírgula (,) e colocado entre chaves ({})

//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");
   }
});

Salve o código acima em um arquivo com o nome Create_Batch.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Create_Batch.js

Isso cria o documento fornecido no banco de dados PouchDB chamado my_databaseque é armazenado localmente. A seguinte mensagem é exibida.

Documents created Successfully

Inserindo um lote em um banco de dados remoto

Você pode inserir uma matriz de documentos no banco de dados que é armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados onde queremos criar documentos no CouchDB.

Exemplo

A seguir está um exemplo de inserção de uma série de documentos no banco de dados denominado my_database que é salvo no servidor 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");
   }
});

Salve o código acima em um arquivo com o nome Remote_Create_Batch.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remote_Create_Batch.js

Isso cria os documentos fornecidos no banco de dados PouchDB chamado my_databaseque é armazenado no CouchDB. A seguinte mensagem é exibida.

Document created Successfully

Verificação

Depois de executar o programa acima, se você visitar o my_database novamente, você pode observar os documentos criados conforme mostrado na imagem a seguir.

Você pode ler / recuperar documentos múltiplos / em massa de um banco de dados no PouchDB usando o allDocs() método.

Sintaxe

A seguir está a sintaxe de uso do db.allDocs()método do PouchDB. Este método aceita uma função de retorno de chamada opcional.

db.allDocs()

Exemplo

A seguir está um exemplo de recuperação de todos os documentos em um banco de dados denominado my_database que é armazenado localmente, usando db.allDocs()método. Este método recupera a matriz de documentos na forma de objetos, para obter o conteúdo de cada documento que você precisa chamar comodocs.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);
   }
});

Salve o código acima em um arquivo com o nome Read_All_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Read_All_Document.js

Isso lê todos os documentos que existem no banco de dados denominado my_databaseque é armazenado localmente. A mensagem a seguir é exibida no console.

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

Em geral, conforme mostrado no resultado acima, usando allDocs() método você pode ver apenas o _id, key e _revcampos de cada documento. No entanto, para incluir todo o documento no resultado, você deve fazer o parâmetro opcionalinclude_docs verdadeiro conforme mostrado abaixo.

//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);
   }
});

Executar o código acima fornece uma lista de documentos completos nos documentos especificados, conforme mostrado no código a seguir.

[ 
   { 
      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' 
      } 
   }
]

Lendo um lote de um banco de dados remoto

Você também pode buscar todos os documentos do banco de dados que está armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados no CouchDB, que contém o documento que deve ser lido.

Exemplo

A seguir está um exemplo de leitura de todos os documentos que existem em um banco de dados denominado my_database que é armazenado no servidor 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);
   }
});

Salve o código acima em um arquivo com o nome Remote_Read_AllDocument.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remote_Read_AllDocument.js

Lê o conteúdo de um determinado documento que existe no banco de dados denominado my_database que é armazenado no CouchDB e exibido no console conforme mostrado abaixo.

[ 
   { 
      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' 
      } 
   } 
]

Você pode atualizar uma série de documentos no PouchDB de uma vez usando o bulkDocs()método. Para fazer isso, você precisa criar uma série de documentos, onde cada documento contém_id, _rev e os valores que devem ser atualizados.

Suponha que o banco de dados denominado my_database que é armazenado localmente no PouchDB contém 3 documentos, nomeadamente doc1, doc2, doc3 com os seguintes conteúdos.

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'}

Suponha que tenhamos que aumentar os valores de idade em todos os 3 documentos em 2 anos. Para que isso aconteça, primeiro você precisa obter o_revvalores. Portanto, busque o conteúdo desses documentos usando o código a seguir.

//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);
   }
});

Salve o código acima como bulk_fetch.js. Na execução, o programa acima fornece os valores _id e _rev dos documentos no banco de dados, conforme mostrado abaixo.

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

Agora, você pode atualizar os documentos usando seus respectivos _id e _rev valores conforme mostrado abaixo.

//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");
   }
});

Salve o código acima em um arquivo com o nome Update_All_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usando o nó conforme mostrado abaixo.

C:\PouchDB_Examples >node Update_All_Document.js

Isso atualiza todos os documentos que existem no banco de dados denominado my_database que é armazenado localmente, exibindo a seguinte mensagem.

Documents Updated Successfully

Agora, se você executar o bulk_fetch.js programa adicionando {include_docs: true} como um parâmetro para allDocs() , antes do callback, então, você poderá ver os valores dos documentos atualizados, conforme mostrado abaixo.

[ 
   { 
      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' 
      } 
   } 
]

Atualizando lote de um banco de dados remoto

Você pode atualizar todos os documentos do banco de dados que estão armazenados remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados no CouchDB, que contém o documento a ser lido.

Exemplo

E suponha que se selecionarmos o banco de dados chamado my_database, você pode observar que ele contém 3 documentos conforme mostrado na imagem a seguir.

Agora, busque o conteúdo desses documentos usando o código a seguir.

//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);
   }
});

Salve o código acima como remote_bulk_fetch.js. Ao ser executado, o programa acima fornece o conteúdo de todos os documentos do banco de dados conforme mostrado abaixo.

[ 
   { 
      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' 
      } 
   } 
]

A seguir está um exemplo de atualização de todos os documentos que existem em um banco de dados denominado my_database que é armazenado no servidor 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"); 
   } 
});

Salve o código acima em um arquivo com o nome Remote_Update_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usando o nó conforme mostrado abaixo.

C:\PouchDB_Examples >node Remote_Update_Document.js

Isso atualiza o conteúdo de todos os documentos que existem no banco de dados denominado my_database que é armazenado no CouchDB e exibe a seguinte mensagem.

Documents Updated Successfully

Agora, se você executar o remote_bulk_fetch.js no programa você poderá ver os valores dos documentos atualizados, conforme mostrado abaixo.

[ 
   { 
      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 
      } 
   } 
]

Você pode deletar uma série de documentos no PouchDB de uma vez usando o bulkDocs()método. Para fazer isso, você precisa criar uma série de documentos que devem ser excluídos, onde cada documento deve conter_id e _rev. Além disso, você deve adicionar outro par de valores-chave_deleted: true.

Suponha que o banco de dados denominado my_database que é armazenado localmente no PouchDB contém 3 documentos, nomeadamente doc1, doc2, doc3 com os seguintes conteúdos.

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'}

E, digamos, temos que excluir todos os três documentos. Então, antes de tudo, você precisa obter seus_revvalores. Portanto, busque o conteúdo desses documentos usando o código a seguir.

//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);
   }
});

Salve o código acima como bulk_fetch.js. Executar o programa acima fornece os valores _id e _rev dos documentos no banco de dados, conforme mostrado abaixo.

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

Agora, você pode excluir os documentos usando seus respectivos _id e _rev valores conforme mostrado abaixo.

//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");
   }
});

Salve o código acima em um arquivo com o nome Delete_All_Document.js. Abra o prompt de comando e execute o arquivo JavaScript usando o nó conforme mostrado abaixo.

C:\PouchDB_Examples >node Delete_All_Document.js

Isso exclui todos os documentos que existem no banco de dados denominado my_database que é armazenado localmente, exibindo a seguinte mensagem.

Documents Deleted Successfully

Agora, se você executar o bulk_fetch.js programa, você pode observar uma chave vazia no console indicando que o banco de dados está vazio, conforme mostrado abaixo.

[]

Excluindo lote de um banco de dados remoto

Você pode atualizar todos os documentos do banco de dados que estão armazenados remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados no CouchDB, que contém o documento a ser lido.

Exemplo

Se selecionarmos o banco de dados chamado my_database, você pode observar que ele contém 3 documentos conforme mostrado na imagem a seguir.

A seguir está um exemplo de exclusão de todos os documentos que existem em um banco de dados denominado my_database que é armazenado no servidor 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");
   }
});

Salve o código acima em um arquivo com o nome Remote_delete_AllDocuments.js. Abra o prompt de comando e execute o arquivo JavaScript usando o nó conforme mostrado abaixo.

C:\PouchDB_Examples >node Remote_Delete_AllDocuments.js

Isso exclui o conteúdo de todos os documentos fornecidos no banco de dados denominado my_database que é armazenado no CouchDB e exibe a seguinte mensagem.

Documents Deleted Successfully

Você pode anexar um objeto binário a um documento usando o putAttachment() método no PouchDB.

Sintaxe

A seguir está a sintaxe do putAttachment(). Para este método, temos que passar a id do documento, id do anexo, tipo MIME junto com o anexo. Este método também aceita uma função de retorno de chamada opcional.

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

Podemos preparar o anexo usando objetos blob ou buffer, onde blob é usado ao trabalhar com o navegador e buffer é usado ao trabalhar com Node.js, como estamos demonstrando nossos programas em Node.js, usamos objetos buffer para preparar documentos.

Exemplo

A seguir está um exemplo de criação de um documento com anexo, dentro de um banco de dados denominado my_database no PouchDB usando putAttachment() método.

//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") 
   } 
});

Salve o código acima em um arquivo com o nome Add_Attachment.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Add_Attachment.js

Isso cria um documento vazio adicionando um anexo a ele, no banco de dados chamado my_database que é armazenado no PouchDB e exibe a seguinte mensagem.

Attachment added successfully

Você pode verificar se o anexo foi adicionado lendo o documento usando o código a seguir.

//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); 
   } 
});

Salve o código acima como read_doc.jse executá-lo. Executando este programa, você pode ver o seguinte conteúdo do documento.

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

Adicionar anexo a um documento existente

Suponha que haja um documento em um banco de dados com o nome my_database PouchDB com id '002'. Você pode obter o conteúdo dele executando oread_doc.js alterando o valor de id para 002, como mostrado abaixo.

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

Agora, você pode adicionar um anexo a este documento usando seu _rev valor.

//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") 
   } 
});

Salve o código acima em um arquivo com o nome Add_Attachment_to_doc.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Add_Attachment_to_doc.js

Isso adiciona um anexo ao documento especificado exibindo a seguinte mensagem.

Attachment added successfully

Se você alterar o valor de id em read_doc.js para 002 e executá-lo, você obterá a seguinte saída.

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

Adicionar anexo a um documento remoto

Você pode até adicionar um anexo ao documento existente em um banco de dados que é armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados no CouchDB, que contém o documento a ser lido.

Exemplo

E se você selecionar o banco de dados chamado my_database, você pode visualizar seu conteúdo conforme mostrado abaixo.

A seguir está um exemplo de adição de um anexo ao documento 001 armazenado em um banco de dados chamado my_database que é armazenado no servidor 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")
   }
});

Salve o código acima em um arquivo com o nome Remote_Add_Attachment.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remote_Add_Attachment.js

Isso adiciona um anexo ao documento especificado exibindo a seguinte mensagem.

Attachment added successfully

Agora, se você verificar o documento, poderá observar o anexo adicionado a ele, conforme mostrado na imagem a seguir.

Você pode recuperar um anexo do PouchDB usando o getAttachment()método. Este método sempre retorna objetos blob ou buffer.

Sintaxe

A seguir está a sintaxe do getAttachment(). Para este método, temos que passar o id do documento e o id do anexo. Este método também aceita uma função de retorno de chamada opcional.

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

Exemplo

A seguir está um exemplo de recuperação de um anexo de um documento armazenado no PouchDB, usando getAttachment()método. Usando este código, estamos tentando recuperar um anexoatt_1.txt do documento 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);
   }
});

Salve o código acima em um arquivo com o nome Retrieve_Attachment.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Retrieve_Attachment.js

Isso recupera o anexo do documento e exibe no console conforme mostrado abaixo.

<Buffer 00>

Recuperando Anexo de um Documento Remoto

Você também pode recuperar um anexo de um documento existente no banco de dados que está armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados no CouchDB, que contém o documento a ser lido.

Exemplo

Se você selecionar o banco de dados chamado my_database, você pode visualizar seu conteúdo conforme mostrado abaixo.

Suponha que haja um anexo neste documento, conforme mostrado abaixo.

A seguir está um exemplo de recuperação de um anexo do documento 001 que existe em um banco de dados chamado my_database, que é armazenado no servidor 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); 
   } 
});

Salve o código acima em um arquivo com o nome Remote_Retrieve_Attachment.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remote_Retrieve_Attachment.js

Isso recupera o anexo do documento e o exibe no console, conforme mostrado abaixo.

<Buffer 00>

Você pode excluir um anexo do PouchDB usando o removeAttachment() método.

Sintaxe

A seguir está a sintaxe do removeAttachment()método. Para este método, temos que passar o id do documento, id do anexo e valor _rev. Este método também aceita uma função de retorno de chamada opcional.

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

Exemplo

Suponha que haja um documento no PouchDB com id 001, que contém id, nome, idade, designação de um funcionário junto com um anexo conforme mostrado abaixo.

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

A seguir está um exemplo de exclusão do anexo deste documento 001 armazenado no PouchDB, usando removeAttachment() método.

//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")
   }
});

Salve o código acima em um arquivo com o nome Remove_Attachment.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remove_Attachment.js

Isso remove o anexo do documento e exibe uma mensagem no console, conforme mostrado abaixo.

Attachment deleted successfully

Após a exclusão, você pode verificar o conteúdo do documento executando o código a seguir.

//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);
   }
});

Salve este código como read.jse executá-lo. Ao executar, você obterá o conteúdo do documento após excluir o anexo, conforme mostrado abaixo.

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

Removendo anexo de um documento remoto

Você pode excluir um anexo de um documento existente no banco de dados que está armazenado remotamente no servidor (CouchDB).

Para fazer isso, em vez de um nome de banco de dados, você precisa passar o caminho para o banco de dados no CouchDB, que contém o documento a ser lido.

Exemplo

E se você selecionar o banco de dados chamado my_database, você pode visualizar seu conteúdo conforme mostrado abaixo.

Suponha que haja um anexo neste documento, conforme mostrado abaixo.

A seguir está um exemplo de exclusão do anexo mencionado acima do documento 001 que existe em um banco de dados chamado my_database que é armazenado no servidor 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") 
   } 
});

Salve o código acima em um arquivo com o nome Remote_Delete_Attachment.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Remote_Delete_Attachment.js

Isso remove o anexo existente e exibe a seguinte mensagem.

Attachment Deleted successfully

Se você visitar o documento novamente, poderá notar que o anexo foi excluído conforme mostrado na imagem a seguir.

Um dos recursos mais importantes do PouchDB é a replicação, ou seja, você pode fazer uma cópia de um banco de dados. Você pode replicar uma instância PouchDB armazenada localmente ou uma instância CouchDB armazenada remotamente.

Sintaxe

A seguir está a sintaxe de replicação de um banco de dados no PouchDB. Aqui, uma cópia dosource databaseé o alvo. Para este método, você pode passar diretamente a localização dos bancos de dados de origem e destino no formato String, ou você pode passar objetos que os representam.

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

Tanto a origem quanto os destinos podem ser instâncias PouchDB ou instâncias CouchDB.

Replicando LocalDB para CouchDB

Suponha que haja um banco de dados com o nome sample_database no PouchDB, e contém 3 documentos doc1, doc2 e doc3, tendo o conteúdo mostrado abaixo.

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'}

A seguir está um exemplo que faz uma cópia do banco de dados chamado sample_database que é armazenado localmente no 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");

Salve o código acima em um arquivo com o nome Replication_example.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Replication_example.js

Isso faz uma cópia do banco de dados denominado sample_database na instância do CouchDB e exibe uma mensagem no console conforme mostrado abaixo.

Database replicated successfully

Você pode verificar se o banco de dados é replicado em sua instância do CouchDB clicando no seguinte link http://127.0.0.1:5984/_utils/index.html.

Ao clicar, você pode ver a lista de bancos de dados em seu CouchDB. Você também pode observar que uma cópia do banco de dadossample_database é criado aqui.

Se você selecionar o banco de dados replicado, poderá visualizar seu conteúdo conforme mostrado abaixo.

Replicando CouchDB para PouchDB

Suponha que haja um banco de dados com o nome Remote_Database no CouchDB e contém 3 documentos, doc1, doc2 e doc3, tendo o conteúdo mostrado abaixo.

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'}

A seguir está um exemplo que faz uma cópia do banco de dados chamado Remote_Database que é armazenado em CouchDB no armazenamento local.

//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");

Salve o código acima em um arquivo com o nome Replication_example2.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Replication_example2.js

Isso faz uma cópia do banco de dados chamado remote_database na instância PouchDB e exibe uma mensagem no console como mostrado abaixo.

Database replicated successfully

Você pode verificar se o banco de dados é replicado em sua instância do Pouch executando o código a seguir.

//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);
   }
});

Se o banco de dados for replicado ao executar o código acima, você obterá o conteúdo do banco de dados replicado conforme mostrado abaixo.

[ 
   { 
      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' 
      } 
   } 
]

Você pode sincronizar os bancos de dados armazenados localmente no PouchDB com aqueles armazenados no CouchDB. No capítulo anterior, vimos como replicar bancos de dados usando PouchDB. Lá nós usamos o métodoPouchDB.replicate(source, destination).

Além disso, também podemos replicar os dados, do banco de dados local para o banco de dados remoto e do banco de dados remoto para o banco de dados local usando replicate.to() e replicate.from() métodos como mostrado abaixo.

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

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

Onde, localDB é um objeto de banco de dados armazenado localmente no PouchDB e remoteDB é um objeto de um banco de dados armazenado no CouchDB.

Exemplo

Suponha que haja um banco de dados com o nome local_database no PouchDB, e contém 3 documentos, doc1, doc2 e doc3, tendo o conteúdo mostrado abaixo.

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'}

E há um banco de dados com o nome Remote_Database no CouchDB e contém 2 documentos doc1, doc2, tendo o conteúdo mostrado abaixo.

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

A seguir está um exemplo de sincronização desses dois bancos de dados, onde um é armazenado no PouchDB e o outro é armazenado no CouchDB, usando o replicate.to() e replicate.from() métodos.

//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");

Salve o código acima em um arquivo com o nome Synchronising_databases.js. Abra o prompt de comando e execute o arquivo JavaScript usandonode como mostrado abaixo.

C:\PouchDB_Examples >node Synchronising_databases.js

Isso sincroniza os dois bancos de dados remoteDB e localDB e exibe uma mensagem no console conforme mostrado abaixo.

Databases synchronized successfully.

Depois de sincronizar os dois bancos de dados, visite o http://127.0.0.1:5984/_utils/index.html e selecione o remote_database. Você pode observar que os documentos do banco de dados local (003, 004, 005) foram copiados neste banco de dados conforme mostrado abaixo.

Da mesma forma, se você buscar o conteúdo do local_database armazenado no PouchDB você pode começar a observar que os documentos do banco de dados que estão armazenados no CouchDB foram copiados aqui.

[ 
   { 
      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' 
      } 
   } 
]

Você pode reescrever o programa acima usando o sync() método fornecido pelo PouchDB em vez dos dois métodos replicate.to() e replicate.from() como mostrado abaixo.

//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);
   }
});

Ao executar o programa acima, ele sincroniza as duas bases de dados exibindo a seguinte mensagem.

{ 
   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) 
   } 
}

Neste capítulo, discutiremos os conceitos como compactação e recuperação de dados em massa do PouchDB.

Compactação

Você pode reduzir o tamanho de um banco de dados removendo os dados não utilizados usando compact()método. Você pode compactar um banco de dados local ou remoto usando este método.

A seguir está um exemplo que demonstra o uso do compact() método no 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);
   }
});

Método BulkGet

Você pode recuperar um conjunto de documentos em massa usando o bulkGet()método. Para este método, você precisa passar um conjunto de id's e _rev's.

A seguir está um exemplo que demonstra o uso do bulkGet() método no 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);
   }
});