sqlite3 usa um modelo de dados relacional, onde os dados são armazenados em tabelas com linhas e colunas. Suporta esquemas de dados estruturados e consultas SQL para manipulação de dados.

lowdb armazena dados em um formato JSON, permitindo estruturas de dados aninhadas e acesso fácil aos dados usando a notação de ponto. É ideal para dados estruturados de forma simples.

levelup usa um modelo de dados baseado em chave-valor, onde os dados são armazenados como pares de chave-valor. Isso permite acesso rápido e eficiente aos dados usando chaves exclusivas.

mongodb-memory-server simula um banco de dados MongoDB, permitindo o armazenamento de dados em documentos JSON. Suporta estruturas de dados complexas e consultas baseadas em documentos.

pouchdb é um banco de dados NoSQL baseado em documentos que armazena dados em formato JSON. Suporta dados não estruturados e semi-estruturados, permitindo flexibilidade na modelagem de dados.

nedb usa um modelo de dados baseado em documentos, semelhante ao MongoDB. Os dados são armazenados em arquivos e podem ser acessados usando chaves, índices ou consultas baseadas em JSON.

sqlite3 fornece persistência de dados em um arquivo de banco de dados SQLite. Os dados são armazenados de forma durável e podem ser acessados usando consultas SQL, garantindo integridade e disponibilidade a longo prazo.

lowdb persiste dados em arquivos JSON, garantindo que os dados sejam salvos entre as execuções do aplicativo. A persistência é simples e baseada em arquivo, tornando-a fácil de usar e entender.

levelup oferece persistência de dados em bancos de dados baseados em chave-valor, como LevelDB. Os dados são armazenados de forma durável no disco, garantindo que permaneçam disponíveis entre as execuções do aplicativo.

mongodb-memory-server fornece persistência de dados em uma instância do MongoDB, mas os dados são armazenados em memória e não são duráveis por padrão. É projetado para testes, onde a persistência a longo prazo não é necessária.

pouchdb oferece persistência de dados tanto no lado do cliente quanto no lado do servidor. Os dados são armazenados localmente e podem ser sincronizados com um banco de dados remoto, como CouchDB, para persistência a longo prazo.

nedb oferece persistência de dados em arquivos, armazenando documentos em um formato binário. Os dados permanecem disponíveis entre as execuções do aplicativo, e o armazenamento é gerenciado automaticamente.

sqlite3 oferece suporte completo a consultas SQL, incluindo seleção, inserção, atualização e exclusão de dados. Suporta consultas complexas, junções e transações, tornando-o poderoso e flexível.

lowdb suporta consultas simples usando a API Lodash, permitindo filtragem, mapeamento e redução de dados. É adequado para consultas leves em dados estruturados.

levelup oferece suporte a consultas básicas baseadas em chave, mas não possui um sistema de consulta avançado. As consultas são realizadas usando chaves, intervalos e iteradores.

mongodb-memory-server suporta consultas avançadas usando a linguagem de consulta do MongoDB. Permite consultas complexas em documentos, incluindo filtragem, agregação e indexação.

pouchdb suporta consultas baseadas em documentos e permite a criação de índices para consultas mais rápidas. A API de consulta é flexível e suporta filtragem e ordenação de dados.

nedb oferece suporte a consultas avançadas com filtragem, ordenação e indexação. Permite consultas complexas em documentos, semelhante ao MongoDB, mas com uma API mais simples.

sqlite3 não oferece suporte nativo à sincronização de dados. A sincronização deve ser implementada manualmente entre diferentes bancos de dados SQLite.

lowdb não possui recursos de sincronização integrados. Os dados são armazenados localmente em arquivos JSON, e a sincronização deve ser gerenciada externamente.

levelup não oferece suporte nativo à sincronização de dados. A sincronização deve ser implementada manualmente, se necessário.

mongodb-memory-server não oferece sincronização de dados, pois é uma instância em memória do MongoDB. A sincronização deve ser implementada em aplicativos que usam o MongoDB real.

pouchdb suporta sincronização bidirecional entre bancos de dados locais e remotos. É projetado para sincronização automática, tornando-o ideal para aplicativos offline e móveis.

nedb não possui recursos de sincronização nativos. A sincronização deve ser implementada manualmente entre diferentes instâncias do banco de dados.

Exemplo de sqlite3

const sqlite3 = require('sqlite3').verbose();
const db = new sqlite3.Database(':memory:');

db.serialize(() => {
  db.run('CREATE TABLE user (id INT, name TEXT)');
  const stmt = db.prepare('INSERT INTO user VALUES (?, ?)');
  stmt.run(1, 'Alice');
  stmt.finalize();

  db.each('SELECT id, name FROM user', (err, row) => {
    console.log(row.id + ': ' + row.name);
  });
});

db.close();

Exemplo de lowdb

const { Low, JSONFile } = require('lowdb');

const db = new Low(new JSONFile('db.json'));

(async () => {
  await db.read();
  db.data ||= { users: [] };
  db.data.users.push({ id: 1, name: 'Alice' });
  await db.write();

  console.log(db.data.users);
})();

Exemplo de levelup

const levelup = require('levelup');
const leveldown = require('leveldown');

const db = levelup(leveldown('./meu-banco-de-dados'));

db.put('chave1', 'valor1', (err) => {
  if (err) return console.error('Erro ao armazenar:', err);
  db.get('chave1', (err, valor) => {
    if (err) return console.error('Erro ao recuperar:', err);
    console.log('Valor recuperado:', valor);
  });
});

Exemplo de mongodb-memory-server

const { MongoMemoryServer } = require('mongodb-memory-server');
const mongoose = require('mongoose');

(async () => {
  const mongoServer = await MongoMemoryServer.create();
  await mongoose.connect(mongoServer.getUri());

  const User = mongoose.model('User', new mongoose.Schema({ name: String }));
  await User.create({ name: 'Alice' });
  const users = await User.find();
  console.log(users);

  await mongoose.disconnect();
  await mongoServer.stop();
})();

Exemplo de pouchdb

const PouchDB = require('pouchdb');
const db = new PouchDB('meu-banco');

db.put({ _id: 'doc1', nome: 'Alice' }).then(() => {
  return db.get('doc1');
}).then((doc) => {
  console.log('Documento recuperado:', doc);
}).catch(console.error);

Exemplo de nedb

const Datastore = require('nedb');
const db = new Datastore({ filename: 'db.nedb', autoload: true });

db.insert({ name: 'Alice' }, (err, doc) => {
  if (err) console.error(err);
  console.log('Documento inserido:', doc);
});

// Consulta
db.find({ name: 'Alice' }, (err, docs) => {
  if (err) console.error(err);
  console.log('Documentos encontrados:', docs);
});