PouchDB - Guida rapida

Questo capitolo fornisce una breve introduzione a PouchDB insieme alle sue caratteristiche e al suo funzionamento.

Cos'è PouchDB?

PouchDB è un open source in-browser database APIscritto in JavaScript. È modellato su Couch DB & minuss; un database NoSQL. Utilizzando questa API, possiamo creare applicazioni che funzionano offline e online. Utilizza internamente WebSQL e IndexedDB per memorizzare i dati.

Come funziona?

In PouchDB, quando l'applicazione è offline, i dati vengono archiviati localmente utilizzando WebSQL e IndexedDB nel browser. Quando l'applicazione torna in linea, viene sincronizzata con CouchDB e con i server compatibili.

Usando PouchDB, puoi comunicare senza problemi con database locali e remoti senza notare alcuna differenza.

Caratteristiche di PouchDB

Di seguito sono riportate le caratteristiche di PouchDB:

  • Cross Browser - L'API fornita da PouchDB funziona allo stesso modo in ogni ambiente, quindi possiamo eseguire un'applicazione PouchDB in vari browser.

  • Light Weight - PouchDB è un'API molto leggera, è anche inclusa facilmente utilizzando solo un tag script.

  • Easy to Learn - Se hai una conoscenza precedente di qualsiasi linguaggio di programmazione, è facile imparare PouchDB.

  • Open Source - PouchDB è un'applicazione Open Source ed è disponibile su GitHub.

Vantaggi di PouchDB

Di seguito sono riportati i vantaggi di PouchDB:

  • Poiché PouchDB risiede all'interno del browser, non è necessario eseguire query sulla rete, il che si traduce in un'esecuzione più rapida delle query.

  • Puoi sincronizzare i dati con qualsiasi server supportato e così facendo puoi eseguire app sia online che offline.

Browser che supportano PouchDB

Di seguito sono riportati i browser che supportano PouchDB:

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

Questo capitolo spiega come scaricare e installare PouchDB nel tuo sistema.

Installazione di PouchDB

Per poter lavorare con PouchDB, è necessario scaricare il file .jsfile e includerlo nel tuo script. Di seguito sono riportati i passaggi per installare PouchDB.

Passo 1

Visitare la home page del sito Web di PouchDB, facendo clic sul seguente collegamento -

https://PouchDB.com/

Passo 2

Fare clic sul pulsante Download nella parte in alto a destra della pagina web come mostrato nello screenshot qui sopra. Questo verrà scaricatoPouchDB-5.3.0.min.js nel tuo sistema.

Passaggio 3

Copia e incolla il file PouchDB-5.3.0.min.js nella directory di lavoro e includerlo nel JavaScript come mostrato nel comando seguente.

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

Installazione di Pouch utilizzando Node.js

Puoi anche installare PouchDB come modulo Node.js. Di seguito sono riportati i passaggi per installare PouchDB utilizzando Node.js.

Passo 1

Installa Node.js seguendo i passaggi indicati nella sezione Installazione di Node.js del nostro tutorial sullo script del caffè .

Passo 2

Apri il prompt dei comandi ed esegui il seguente comando. Questo installerà il modulo del nodo PouchDB nel tuo sistema.

npm install --save PouchDB

Download di CouchDB

Quando offline, PouchDB memorizza i dati localmente e funziona come un'app. Puoi accedervi online collegandoti a server compatibili. Come sappiamo, PouchDB può essere collegato a CouchDB, quindi installiamo anche CouchDB. Di seguito sono riportati i passaggi per installare CouchDB.

Passo 1

Il sito web ufficiale di CouchDB è http://couchdb.apache.org. Se si fa clic sul collegamento fornito, è possibile ottenere la home page del sito Web ufficiale di CouchDB come mostrato nella schermata seguente.

Passo 2

Se si fa clic sul pulsante di download, verrà visualizzata una pagina in cui sono forniti i collegamenti per il download di CouchDB in vari formati. La seguente istantanea illustra lo stesso.

Passaggio 3

Scegli il collegamento per il download per i sistemi Windows e seleziona uno dei mirror forniti per avviare il download.

Installazione di CouchDB

Un eseguibile di Windows setup-couchdb-1.6.1_R16B02.exeil file verrà scaricato sul tuo sistema. Eseguire il file di installazione e procedere con l'installazione.

Dopo aver installato correttamente CouchDB nel tuo sistema, apri la cartella in cui è stato installato CouchDB, vai alla cartella bin e avvia il server eseguendo un file di script denominato couchdb.bat.

Dopo l'installazione, apri l'interfaccia web integrata di CouchDB visitando il seguente link - http://127.0.0.1:5984/. Se tutto va bene, questo ti darà una pagina web, che avrà il seguente output.

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

Puoi interagire con l'interfaccia web di CouchDB utilizzando il seguente URL:

http://127.0.0.1:5984/_utils/

Questo ti mostra la pagina dell'indice di Futon, che è l'interfaccia web di CouchDB.

È possibile creare un database in PouchDB utilizzando il costruttore PouchDB.

Sintassi

Di seguito è riportata la sintassi per l'utilizzo del costruttore PouchDB. A tal fine, è necessario passare il nome del database come parametro.

new PouchDB(Database_name)

Esempio

Per creare un database in PouchDB utilizzando node, prima di tutto, devi richiedere il pacchetto PouchDB utilizzando l'estensione require() metodo e quindi è possibile creare un database come mostrato nell'esempio seguente.

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

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

Salva il codice sopra in un file con il nome Create_Database.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples>node Create_Database.js

Questo creerà un database localmente (puoi vedere la cartella nella directory corrente) visualizzando il seguente messaggio.

Database created Successfully.

È possibile ottenere le informazioni di base sul database utilizzando il metodo denominato info()

Sintassi

Di seguito è riportata la sintassi dell'utilizzo di info()metodo di PouchDB. Questo metodo accetta una funzione di callback.

db.info([callback])

Esempio

Di seguito è riportato un esempio di recupero delle informazioni del database utilizzando info()metodo. Qui stiamo visualizzando le informazioni del database denominatomy_database. In caso di errore, l'errore verrà visualizzato sulla 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);
   }
});

Salva il codice sopra in un file con il nome Database_info.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples>node Database_info.js

Questo mostrerà le informazioni del database specificato come segue.

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

Informazioni sul database remoto

Allo stesso modo, ottieni le informazioni di un database che viene salvato in remoto sul server (CouchDB). Per fare ciò, invece del nome del database, è necessario passare il percorso al database richiesto in CouchDB.

Esempio

Di seguito è riportato un esempio di recupero delle informazioni di un database salvato nel server CouchDB. Questo codice fornisce informazioni su un database denominatomy_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);
   }
});

Salva il codice sopra in un file con il nome Database_ Remote_info.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples>node Database_Remote_info.js

Questo mostrerà le informazioni del database specificato come segue.

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

È possibile eliminare un database in PouchDB utilizzando il db.destroy() metodo.

Sintassi

Di seguito è riportata la sintassi dell'utilizzo di db.destroy()metodo. Questo metodo accetta una funzione di callback come parametro.

db.destroy()

Esempio

Di seguito è riportato un esempio di eliminazione di un database in PouchDB utilizzando l'estensione destroy()metodo. Qui stiamo eliminando il database denominatomy_database, creato nei capitoli precedenti.

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

Salva il codice sopra in un file con il nome Delete_Database.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzando node come mostrato di seguito.

C:\PouchDB_Examples >node Delete_Database.js

Questo eliminerà il database denominato my_database che viene memorizzato localmente visualizzando il seguente messaggio.

Database Deleted

Eliminazione di un database remoto

Allo stesso modo, è possibile eliminare un database memorizzato in remoto sul server (CouchDB).

Per fare ciò, invece del nome di un database, è necessario passare il percorso al database che deve essere eliminato, in CouchDB.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

Di seguito è riportato un esempio di eliminazione di un database denominato my_database che viene salvato nel server 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");
   }
});

Salva il codice sopra in un file con il nome Remote_Database_Delete.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >Remote_Database_Delete.js

Questo elimina il database specificato da PouchDB visualizzando il seguente messaggio.

Database Deleted

Verifica

Dopo aver eseguito il programma sopra, se visiti nuovamente l'URL, otterrai la seguente schermata. Da allora puoi osservare solo due databasemy_database è stato eliminato.

Puoi creare un documento in PouchDB usando il db.put() metodo.

Sintassi

Di seguito è riportata la sintassi dell'utilizzo del metodo db.put () di PouchDB. È possibile memorizzare il documento che si desidera creare in PouchDB, in una variabile e passare come parametro a questo metodo. Inoltre, questo metodo accetta anche una funzione di callback (opzionale) come parametro.

db.put(document, callback)

Esempio

Di seguito è riportato un esempio di creazione di un documento in PouchDB utilizzando l'estensione put()metodo. Il documento che creiamo dovrebbe essere in formato JSON, un insieme di coppie chiave-valore separate da virgola (,) e racchiuso tra parentesi graffe ({}).

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

Salva il codice sopra in un file con nome Create_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Create_Document.js

Questo crea il documento dato nel database PouchDB denominato my_database, che è memorizzato localmente, visualizzando il seguente messaggio.

Document created Successfully

Inserimento di un documento in un database remoto

È inoltre possibile inserire un documento nel database memorizzato in remoto sul server (CouchDB).

Per fare ciò, invece del nome del database è necessario passare il percorso al database in cui si desidera creare i documenti in CouchDB.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

Ora, se fai clic sul database denominato my_database, troverai un database vuoto come mostrato nello screenshot seguente.

Di seguito è riportato un esempio di inserimento di un documento in un database denominato my_database che viene salvato nel server 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");
   }
});

Salva il codice sopra in un file con il nome Remote_Create_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Create_Document.js

Questo crea il documento dato nel database PouchDB denominato my_database che è memorizzato in CouchDB, visualizzando il seguente messaggio.

Document created Successfully

Verifica

Dopo aver eseguito il programma sopra, se visiti il ​​file my_database di nuovo, puoi osservare il documento creato come mostrato nello screenshot seguente.

Puoi leggere / recuperare il contenuto di un documento in PouchDB usando il db.get() metodo.

Sintassi

Di seguito è riportata la sintassi dell'utilizzo di db.get()metodo di PouchDB. Questo metodo accetta l'estensionedocument id e una funzione di callback opzionale.

db.get(document, callback)

Esempio

Di seguito è riportato un esempio di lettura del contenuto di un documento in PouchDB utilizzando l'estensione get() metodo.

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

Salva il codice sopra in un file con nome Read_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzando il nodo come mostrato di seguito.

C:\PouchDB_Examples >node Read_Document.js

Questo legge il contenuto del documento dato che esiste nel database denominato my_databaseche è memorizzato localmente. Il seguente messaggio viene visualizzato sulla console.

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

Lettura di un documento da un database remoto

È inoltre possibile leggere un documento dal database archiviato in remoto sul server (CouchDB).

Per fare ciò, invece del nome di un database, è necessario passare il percorso al database in CouchDB, che contiene il documento che deve essere letto.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

Cliccando sul database denominato my_databasepuoi vedere il seguente screenshot. Qui puoi osservare che questo database contiene un documento con id001.

Di seguito è riportato un esempio di lettura del contenuto del documento avente id come "001"Che esiste in un database denominato my_database, che è memorizzato nel server 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);
   }
});

Salva il codice sopra in un file con il nome Remote_Read_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Read_Document.js

Questo legge il contenuto del documento dato che esiste nel database denominato my_databaseche è memorizzato in CouchDB. Il seguente messaggio viene visualizzato sulla console.

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

Ogni volta che creiamo un documento in PouchDB, un nuovo campo _rev viene generato ed è noto come revision marker. Il_revIl valore di è un numero casuale univoco, ogni volta che apportiamo modifiche al documento il valore di _rev è cambiato.

Puoi aggiornare un documento esistente in PouchDB usando il (_rev). Per fare ciò, prima di tutto recupera il file_revvalore del documento che vogliamo aggiornare. Ora, posiziona i contenuti che devono essere aggiornati insieme a quelli recuperati_rev valore in un nuovo documento e infine inserire questo documento in PouchDB utilizzando il put() metodo.

Esempio

Supponiamo di avere un documento in PouchDB con id 001che contiene i dettagli di una persona. Per aggiornare questo documento, dovremmo avere il suo numero di revisione. Pertanto, per recuperare il contenuto del documento viene utilizzato il codice seguente.

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

Eseguendo il codice sopra, riceverai il seguente output.

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

Ora, usando il _rev puoi aggiornare il valore della chiave "age"A 26, come mostrato nel codice seguente.

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

Salva il codice sopra in un file con il nome Update_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\Pouch_Examples>node Update_Document.js

Questo aggiorna il contenuto del documento dato che esiste nel database denominato my_databaseche è memorizzato localmente. Il seguente messaggio viene visualizzato sulla console.

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

Aggiornamento di un documento in un database remoto

È inoltre possibile aggiornare un documento esistente in un database archiviato in remoto sul server (CouchDB).

Per fare ciò, invece di un nome di database è necessario passare il percorso al database in CouchDB, che contiene il documento che deve essere aggiornato.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

Cliccando sul database denominato my_database, puoi vedere il seguente screenshot. Qui puoi osservare che questo database contiene un documento con id001.

Di seguito è riportato un esempio di aggiornamento dell'età del documento con ID come "001"Che esiste in un database denominato my_database che è memorizzato nel server 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);
   }
});

Salva il codice sopra in un file con il nome Remote_Update_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Update_Document.js

Questo aggiorna il contenuto del documento dato che esiste nel database denominato my_databaseche è memorizzato in CouchDB. Il seguente messaggio viene visualizzato sulla console.

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

È possibile eliminare un documento da un database esistente in PouchDB utilizzando l'estensione db.remove() metodo.

Sintassi

Di seguito è riportata la sintassi dell'utilizzo di db.remove()metodo di PouchDB. A questo metodo, dobbiamo passareid e _revper eliminare un documento esistente come mostrato nel codice seguente. Questo metodo accetta una funzione di callback opzionale. Possiamo anche passare il documento completo invece di id e _rev.

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

Esempio

Supponiamo di avere un documento in PouchDB con id 001che hanno i dettagli di una persona. Per eliminare questo documento insieme al suo fileid dovremmo anche avere il suo _revnumero. Pertanto, recuperare il contenuto del documento come illustrato nel codice seguente.

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

L'esecuzione del codice precedente restituisce il seguente output.

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

Ora, usando il _rev e l'ID del documento è possibile eliminarlo utilizzando il remove() metodo come mostrato nel codice seguente.

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

Salva il codice sopra in un file con il nome Delete_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Delete_Document.js

Ciò elimina il contenuto del documento specificato che esiste nel database denominato my_databaseche è memorizzato localmente. Viene visualizzato il messaggio seguente.

Document deleted successfully

Eliminazione di un documento da un database remoto

È inoltre possibile eliminare un documento esistente dal database archiviato in remoto sul server (CouchDB).

Per fare ciò, invece del nome di un database, è necessario passare il percorso al database in CouchDB, che contiene il documento che deve essere letto.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

Cliccando sul database denominato my_databasepuoi vedere il seguente screenshot. Qui puoi osservare che il database contiene un documento con id001.

Di seguito è riportato un esempio di eliminazione dei contenuti del documento con ID "001"Che esiste in un database denominato my_database che è memorizzato nel server 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");
   }
});

Salva il codice sopra in un file con nome Remote_Delete_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Delete_Document.js

Ciò elimina il documento specificato che esiste nel database denominato my_databaseche è memorizzato in CouchDB. Viene visualizzato il messaggio seguente.

Document deleted successfully

È possibile creare un array (batch) di documenti in PouchDB utilizzando l'estensione db.bulkDocs()metodo. Durante la creazione dei documenti, utilizzando questo metodo se non forniamo valori _id, PouchDB genera per nostro conto ID univoci per tutti i documenti in blocco.

Sintassi

Di seguito è riportata la sintassi dell'utilizzo di db.bulkDocs()metodo di PouchDB. È possibile memorizzare tutti i documenti che devono essere creati in PouchDB in un array e passarli a questo metodo come parametro. Oltre a ciò, questo metodo accetta anche una funzione di callback (opzionale) come parametro.

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

Esempio

Di seguito è riportato un esempio di creazione di più documenti in PouchDB utilizzando l'estensione db.bulkDocs ()metodo. I documenti che creiamo dovrebbero essere in formato JSON, un insieme di coppie chiave-valore separate da virgola (,) e racchiuso tra parentesi graffe ({}).

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

Salva il codice sopra in un file con nome Create_Batch.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Create_Batch.js

Questo crea il documento dato nel database PouchDB denominato my_databaseche è memorizzato localmente. Viene visualizzato il messaggio seguente.

Documents created Successfully

Inserimento di un batch in un database remoto

È possibile inserire una matrice di documenti nel database archiviato in remoto sul server (CouchDB).

Per fare ciò, invece del nome di un database è necessario passare il percorso al database in cui vogliamo creare i documenti in CouchDB.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

Di seguito è riportato un esempio di inserimento di un array di documenti nel database denominato my_database che viene salvato nel server 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");
   }
});

Salva il codice sopra in un file con il nome Remote_Create_Batch.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Create_Batch.js

Questo crea i documenti dati nel database PouchDB denominato my_databaseche è memorizzato in CouchDB. Viene visualizzato il messaggio seguente.

Document created Successfully

Verifica

Dopo aver eseguito il programma sopra, se visiti il my_database di nuovo, puoi osservare i documenti creati come mostrato nello screenshot seguente.

Puoi leggere / recuperare documenti multipli / in blocco da un database in PouchDB usando il allDocs() metodo.

Sintassi

Di seguito è riportata la sintassi dell'utilizzo di db.allDocs()metodo di PouchDB. Questo metodo accetta una funzione di callback opzionale.

db.allDocs()

Esempio

Di seguito è riportato un esempio di recupero di tutti i documenti in un database denominato my_database che viene memorizzato localmente, utilizzando db.allDocs()metodo. Questo metodo recupera la matrice di documenti sotto forma di oggetti, per ottenere il contenuto di ogni documento che devi chiamare comedocs.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);
   }
});

Salva il codice sopra in un file con il nome Read_All_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Read_All_Document.js

Questo legge tutti i documenti che esistono nel database denominato my_databaseche è memorizzato localmente. Il seguente messaggio viene visualizzato sulla 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' } 
   }
]

In generale, come mostrato nel risultato sopra, utilizzando allDocs() puoi vedere solo il metodo _id, key e _revcampi di ogni documento. Tuttavia, per includere l'intero documento nel risultato, è necessario creare il parametro facoltativoinclude_docs true come mostrato di seguito.

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

L'esecuzione del codice precedente fornisce un elenco di documenti completi nei documenti specificati, come mostrato nel codice seguente.

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

Lettura di un batch da un database remoto

È inoltre possibile recuperare tutti i documenti dal database archiviato in remoto sul server (CouchDB).

Per farlo invece del nome di un database, è necessario passare il percorso al database in CouchDB, che contiene il documento che deve essere letto.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

Di seguito è riportato un esempio di lettura di tutti i documenti che esistono in un database denominato my_database che è memorizzato nel server 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);
   }
});

Salva il codice sopra in un file con il nome Remote_Read_AllDocument.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Read_AllDocument.js

Questo legge il contenuto del documento dato che esiste nel database denominato my_database che è memorizzato in CouchDB e viene visualizzato sulla console come mostrato di seguito.

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

Puoi aggiornare una serie di documenti in PouchDB contemporaneamente utilizzando il file bulkDocs()metodo. Per fare ciò è necessario creare una matrice di documenti in cui ogni documento contiene_id, _rev e i valori che devono essere aggiornati.

Supponiamo che il database denominato my_database che è memorizzato localmente in PouchDB contiene 3 documenti cioè doc1, doc2, doc3 con i seguenti contenuti.

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

Supponiamo di dover aumentare di 2 anni i valori di età in tutti e 3 i documenti. Affinché ciò accada, prima devi ottenere il file_revvalori. Pertanto, recuperare il contenuto di questi documenti utilizzando il codice seguente.

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

Salva il codice sopra come bulk_fetch.js. All'esecuzione, il programma precedente fornisce i valori _id e _rev dei documenti nel database come mostrato di seguito.

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

Ora puoi aggiornare i documenti usando i rispettivi _id e _rev valori come mostrato di seguito.

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

Salva il codice sopra in un file con il nome Update_All_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzando il nodo come mostrato di seguito.

C:\PouchDB_Examples >node Update_All_Document.js

Questo aggiorna tutti i documenti che esistono nel database denominato my_database che è memorizzato localmente, visualizzando il seguente messaggio.

Documents Updated Successfully

Ora, se esegui il file bulk_fetch.js programma aggiungendo {include_docs: true} come parametro per allDocs() funzione, prima del callback, poi, potrai vedere i valori dei documenti aggiornati, come mostrato di seguito.

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

Aggiornamento batch da un database remoto

È possibile aggiornare tutti i documenti dal database archiviato in remoto sul server (CouchDB).

Per fare ciò, invece del nome di un database, è necessario passare il percorso al database in CouchDB, che contiene il documento che deve essere letto.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

E supponiamo che se selezioniamo il database denominato my_database, puoi osservare che contiene 3 documenti come mostrato nello screenshot seguente.

Ora, recupera il contenuto di questi documenti utilizzando il codice seguente.

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

Salva il codice sopra come remote_bulk_fetch.js. All'esecuzione, il programma di cui sopra fornisce il contenuto di tutti i documenti nel database come mostrato di seguito.

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

Di seguito è riportato un esempio di aggiornamento di tutti i documenti esistenti in un database denominato my_database che è memorizzato nel server 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"); 
   } 
});

Salva il codice sopra in un file con il nome Remote_Update_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzando il nodo come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Update_Document.js

Questo aggiorna il contenuto di tutto il documento dato che esiste nel database denominato my_database che è memorizzato in CouchDB e visualizza il seguente messaggio.

Documents Updated Successfully

Ora, se esegui il file remote_bulk_fetch.js programma potrai vedere i valori dei documenti aggiornati, come mostrato di seguito.

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

Puoi eliminare un array di documenti in PouchDB contemporaneamente utilizzando il file bulkDocs()metodo. Per fare ciò è necessario creare un array di documenti che devono essere eliminati dove, ogni documento dovrebbe contenere_id e _rev. Oltre a questi, devi aggiungere un'altra coppia chiave-valore_deleted: true.

Supponiamo che il database denominato my_database che è memorizzato localmente in PouchDB contiene 3 documenti cioè doc1, doc2, doc3 con i seguenti contenuti.

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 diciamo, dobbiamo eliminare tutti e tre i documenti. Quindi, prima di tutto devi ottenere il loro_revvalori. Pertanto, recuperare il contenuto di questi documenti utilizzando il codice seguente.

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

Salva il codice sopra come bulk_fetch.js. L'esecuzione del programma precedente fornisce i valori _id e _rev dei documenti nel database come mostrato di seguito.

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

Ora puoi eliminare i documenti utilizzando i rispettivi file _id e _rev valori come mostrato di seguito.

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

Salva il codice sopra in un file con il nome Delete_All_Document.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzando il nodo come mostrato di seguito.

C:\PouchDB_Examples >node Delete_All_Document.js

Ciò elimina tutti i documenti esistenti nel database denominato my_database che è memorizzato localmente, visualizzando il seguente messaggio.

Documents Deleted Successfully

Ora, se esegui il file bulk_fetch.js programma, è possibile osservare una parentesi graffa vuota sulla console che indica che il database è vuoto, come mostrato di seguito.

[]

Eliminazione di batch da un database remoto

È possibile aggiornare tutti i documenti dal database archiviato in remoto sul server (CouchDB).

Per fare ciò, invece del nome di un database, è necessario passare il percorso al database in CouchDB, che contiene il documento che deve essere letto.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

Se selezioniamo il database denominato my_database, puoi osservare che contiene 3 documenti come mostrato nello screenshot seguente.

Di seguito è riportato un esempio di eliminazione di tutti i documenti presenti in un database denominato my_database che è memorizzato nel server 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");
   }
});

Salva il codice sopra in un file con nome Remote_delete_AllDocuments.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzando il nodo come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Delete_AllDocuments.js

Ciò elimina il contenuto di tutto il documento fornito che esiste nel database denominato my_database che è memorizzato in CouchDB e visualizza il seguente messaggio.

Documents Deleted Successfully

È possibile allegare un oggetto binario a un documento utilizzando il putAttachment() metodo in PouchDB.

Sintassi

Di seguito è riportata la sintassi di putAttachment(). A questo metodo, dobbiamo passare l'ID del documento, l'ID dell'allegato, il tipo MIME insieme all'allegato. Questo metodo accetta anche una funzione di callback opzionale.

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

Possiamo preparare l'allegato usando oggetti blob o buffer, dove blob viene utilizzato mentre si lavora con il browser e buffer viene utilizzato mentre si lavora con Node.js, poiché stiamo dimostrando i nostri programmi in Node.js, utilizziamo oggetti buffer per preparare i documenti.

Esempio

Di seguito è riportato un esempio di creazione di un documento con un allegato, all'interno di un database denominato my_database in PouchDB utilizzando putAttachment() metodo.

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

Salva il codice sopra in un file con nome Add_Attachment.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Add_Attachment.js

Questo crea un documento vuoto aggiungendovi un allegato, nel database denominato my_database che è memorizzato in PouchDB e visualizza il seguente messaggio.

Attachment added successfully

È possibile verificare se l'allegato viene aggiunto leggendo il documento utilizzando il codice seguente.

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

Salva il codice sopra come read_doc.jsed eseguirlo. Eseguendo questo programma, puoi vedere i seguenti contenuti del documento.

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

Aggiunta di allegati a un documento esistente

Supponiamo che ci sia un documento in un database con il nome my_database PouchDB con ID '002'. Puoi ottenerne il contenuto eseguendo il fileread_doc.js modificando il valore id in 002, come mostrato di seguito.

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

Ora puoi aggiungere un allegato a questo documento usando il suo _rev valore.

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

Salva il codice sopra in un file con il nome Add_Attachment_to_doc.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Add_Attachment_to_doc.js

Ciò aggiunge un allegato al documento specificato che visualizza il seguente messaggio.

Attachment added successfully

Se modifichi il valore id in read_doc.js per 002 ed eseguendolo, otterrai il seguente output.

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

Aggiunta di allegati a un documento remoto

È anche possibile aggiungere un allegato al documento esistente in un database archiviato in remoto sul server (CouchDB).

Per fare ciò, invece del nome di un database, è necessario passare il percorso al database in CouchDB, che contiene il documento che deve essere letto.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

E se selezioni il database denominato my_database, puoi visualizzarne il contenuto come mostrato di seguito.

Di seguito è riportato un esempio di aggiunta di un allegato al documento 001 archiviato in un database denominato my_database che è memorizzato nel server 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")
   }
});

Salva il codice sopra in un file con il nome Remote_Add_Attachment.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Add_Attachment.js

Ciò aggiunge un allegato al documento specificato che visualizza il seguente messaggio.

Attachment added successfully

Ora, se verifichi il documento, puoi osservare l'allegato aggiunto ad esso come mostrato nello screenshot seguente.

È possibile recuperare un allegato da PouchDB utilizzando il file getAttachment()metodo. Questo metodo restituisce sempre oggetti BLOB o buffer.

Sintassi

Di seguito è riportata la sintassi di getAttachment(). A questo metodo, dobbiamo passare l'ID del documento e l'ID dell'allegato. Questo metodo accetta anche una funzione di callback opzionale.

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

Esempio

Di seguito è riportato un esempio di recupero di un allegato di un documento archiviato in PouchDB, utilizzando getAttachment()metodo. Utilizzando questo codice, stiamo cercando di recuperare un allegatoatt_1.txt dal 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);
   }
});

Salva il codice sopra in un file con il nome Retrieve_Attachment.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Retrieve_Attachment.js

Ciò recupera l'allegato del documento e viene visualizzato sulla console come mostrato di seguito.

<Buffer 00>

Recupero dell'allegato da un documento remoto

È inoltre possibile recuperare un allegato di un documento esistente nel database archiviato in remoto sul server (CouchDB).

Per fare ciò, invece del nome di un database, è necessario passare il percorso al database in CouchDB, che contiene il documento che deve essere letto.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

Se selezioni il database denominato my_database, puoi visualizzarne il contenuto come mostrato di seguito.

Supponiamo che ci sia un allegato in questo documento come mostrato di seguito.

Di seguito è riportato un esempio di recupero di un allegato del documento 001 che esiste in un database denominato my_database, che è memorizzato nel server 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); 
   } 
});

Salva il codice sopra in un file con il nome Remote_Retrieve_Attachment.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Retrieve_Attachment.js

Questo recupera il documento allegato e lo visualizza sulla console come mostrato di seguito.

<Buffer 00>

È possibile eliminare un allegato da PouchDB utilizzando il file removeAttachment() metodo.

Sintassi

Di seguito è riportata la sintassi di removeAttachment()metodo. A questo metodo, dobbiamo passare l'ID documento, l'ID allegato e il valore _rev. Questo metodo accetta anche una funzione di callback opzionale.

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

Esempio

Supponiamo che ci sia un documento in PouchDB con id 001, che contiene ID, nome, età, designazione di un dipendente insieme a un allegato come mostrato di seguito.

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

Di seguito è riportato un esempio di eliminazione dell'allegato di questo documento 001 archiviato in PouchDB, utilizzando removeAttachment() metodo.

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

Salva il codice sopra in un file con il nome Remove_Attachment.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remove_Attachment.js

Ciò rimuove l'allegato del documento e visualizza un messaggio sulla console come mostrato di seguito.

Attachment deleted successfully

Dopo l'eliminazione, è possibile verificare il contenuto del documento eseguendo il codice seguente.

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

Salva questo codice come read.jsed eseguirlo. All'esecuzione, otterrai il contenuto del documento dopo aver eliminato l'allegato, come mostrato di seguito.

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

Rimozione di un allegato da un documento remoto

È possibile eliminare un allegato di un documento esistente nel database archiviato in remoto sul server (CouchDB).

Per fare ciò, invece del nome di un database, è necessario passare il percorso al database in CouchDB, che contiene il documento che deve essere letto.

Esempio

Supponiamo che ci sia un database denominato my_databasenel server CouchDB. Quindi, se verifichi l'elenco dei database in CouchDB utilizzando l'URLhttp://127.0.0.1:5984/_utils/index.html otterrai il seguente screenshot.

E se selezioni il database denominato my_database, puoi visualizzarne il contenuto come mostrato di seguito.

Supponiamo che ci sia un allegato in questo documento come mostrato di seguito.

Di seguito è riportato un esempio di eliminazione del suddetto allegato del documento 001 che esiste in un database denominato my_database che è memorizzato nel server 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") 
   } 
});

Salva il codice sopra in un file con il nome Remote_Delete_Attachment.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Remote_Delete_Attachment.js

Ciò rimuove l'allegato esistente e visualizza il seguente messaggio.

Attachment Deleted successfully

Se visiti di nuovo il documento, puoi notare che l'allegato è stato eliminato come mostrato nella seguente schermata.

Una delle caratteristiche più importanti di PouchDB è la replica, ovvero è possibile creare una copia di un database. Puoi replicare un'istanza PouchDB archiviata localmente o un'istanza CouchDB archiviata in remoto.

Sintassi

Di seguito è riportata la sintassi per replicare un database in PouchDB. Qui, una copia del filesource databaseè l'obiettivo. A questo metodo è possibile passare direttamente la posizione dei database di origine e di destinazione in formato String oppure è possibile passare gli oggetti che li rappresentano.

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

Sia l'origine che le destinazioni possono essere istanze PouchDB o CouchDB.

Replica di LocalDB in CouchDB

Supponiamo che ci sia un database con il nome sample_database in PouchDB e contiene 3 documenti doc1, doc2 e doc3, con contenuti come mostrato di seguito.

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

Di seguito è riportato un esempio che crea una copia del database denominato sample_database archiviato localmente in 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");

Salva il codice sopra in un file con nome Replication_example.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Replication_example.js

Ciò crea una copia del database denominato sample_database nell'istanza di CouchDB e visualizza un messaggio sulla console come mostrato di seguito.

Database replicated successfully

È possibile verificare se il database viene replicato nell'istanza CouchDB facendo clic sul collegamento seguente http://127.0.0.1:5984/_utils/index.html.

Facendo clic, puoi vedere l'elenco dei database nel tuo CouchDB. Puoi anche osservare che una copia del databasesample_database viene creato qui.

Se si seleziona il database replicato, è possibile visualizzarne il contenuto come mostrato di seguito.

Replica da CouchDB a PouchDB

Supponiamo che ci sia un database con il nome Remote_Database in CouchDB e contiene 3 documenti, doc1, doc2 e doc3, con contenuti come mostrato di seguito.

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

Di seguito è riportato un esempio che crea una copia del database denominato Remote_Database che è memorizzato in CouchDB nella memoria locale.

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

Salva il codice sopra in un file con il nome Replication_example2.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Replication_example2.js

Questo crea una copia del database denominato remote_database nell'istanza di PouchDB e visualizza un messaggio sulla console come mostrato di seguito.

Database replicated successfully

È possibile verificare se il database viene replicato nell'istanza di Pouch eseguendo il codice seguente.

//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 il database viene replicato durante l'esecuzione del codice precedente, otterrai il contenuto del database replicato come mostrato di seguito.

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

È possibile sincronizzare i database archiviati localmente in PouchDB con quelli archiviati in CouchDB. Nel capitolo precedente, abbiamo visto come replicare database utilizzando PouchDB. Lì abbiamo usato il metodoPouchDB.replicate(source, destination).

Oltre a questo, possiamo anche replicare i dati, dal database locale al database remoto, e dal database remoto al database locale utilizzando replicate.to() e replicate.from() metodi come mostrato di seguito.

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

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

Dove, localDB è un oggetto di database archiviato localmente in PouchDB e remoteDB è un oggetto di un database archiviato in CouchDB.

Esempio

Supponiamo che ci sia un database con il nome local_database in PouchDB e contiene 3 documenti, doc1, doc2 e doc3, con contenuti come mostrato di seguito.

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 c'è un database con il nome Remote_Database in CouchDB e contiene 2 documenti doc1, doc2, con contenuti come mostrato di seguito.

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

Di seguito è riportato un esempio di sincronizzazione di questi due database, in cui uno è archiviato in PouchDB e l'altro è archiviato in CouchDB, utilizzando il replicate.to() e replicate.from() metodi.

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

Salva il codice sopra in un file con il nome Synchronising_databases.js. Apri il prompt dei comandi ed esegui il file JavaScript utilizzandonode come mostrato di seguito.

C:\PouchDB_Examples >node Synchronising_databases.js

Questo sincronizza i due database remoteDB e localDB e visualizza un messaggio sulla console come mostrato di seguito.

Databases synchronized successfully.

Dopo aver sincronizzato i due database, visitare il http://127.0.0.1:5984/_utils/index.html e seleziona il file remote_database. È possibile osservare che i documenti del database locale (003, 004, 005) sono stati copiati in questo database come mostrato di seguito.

Allo stesso modo, se recuperi il contenuto del file local_database archiviato in PouchDB si può arrivare a osservare che i documenti del database archiviato in CouchDB sono stati copiati qui.

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

È possibile riscrivere il programma precedente utilizzando il file sync() metodo fornito da PouchDB invece dei due metodi replicate.to() e replicate.from() come mostrato di seguito.

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

All'esecuzione del suddetto programma sincronizza i due database visualizzando il seguente messaggio.

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

In questo capitolo, discuteremo i concetti come, compattazione e recupero di dati di massa da PouchDB.

Compattazione

È possibile ridurre le dimensioni di un database rimuovendo i dati inutilizzati utilizzando compact()metodo. È possibile compattare un database locale e un database remoto utilizzando questo metodo.

Di seguito è riportato un esempio che dimostra l'utilizzo di compact() metodo in 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);
   }
});

Metodo BulkGet

Puoi recuperare un insieme di documenti in blocco utilizzando il bulkGet()metodo. A questo metodo, è necessario passare una serie di ID e _rev.

Di seguito è riportato un esempio che dimostra l'utilizzo di bulkGet() metodo in 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);
   }
});
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved