我正在建立一个nodejs应用程序，并在nosql mongodb vs rmds Postregressql之间完全撕裂。我的项目是创建一个开源示例项目，用于记录访问者和使用nodejs在网页上实时显示访问者统计信息。我计划首先使用mongodb，因为很多nodejs的例子和教程，albiet主要是较旧的，使用它和paas主机与免费teir都是丰富。然而，我最近看到很多bong在mongodb，发现试图使用mongodb的人最终切换到postgres。 http://blog.engineering.kiip.me/post/20988881092/a-year-with-mongodb http://dieswaytoofast.blogspot.com/2012/09/mysql-vs-postgres-vs-mongodb.html http://www.plotprojects.com/why-we-use-postgresql-and-slick/我也是heroku的粉丝，听说了很多关于postgress因为，并发现SQL查询可以很好有时。

我不是一个数据库专家，所以我不能告诉我的生活的方式去。如果你能给出一些建议，考虑哪一个和为什么，我真的apreaciate。

我有几个标准：

>因为我想这是一个例子，这将是很高兴有一个方法来托管一个规模大小的数据量。我知道mongodb defiantly提供这一点，但postgres帕拉像heroku似乎有很小的数据库(因为我记录每个访问者的网站)
>一个简单的数据库，很容易向他人解释。
>性能并不重要，但速度不能伤害

感谢所有的帮助！

注：请不要火焰大战，大家有自己的看法:)

在sql数据库和Nosql数据库之间进行选择当然是正在争论的很大，现在有很多关于这个问题的好文章。我会在结尾列出一对夫妇。我没有问题推荐sql over NOsql为您的特殊需求。

Nosql有一个小组的用例，其中数据存储在称为文档的大型紧密耦合的包中，而不是在关系模型中。简而言之，紧密耦合到单个实体(如单个用户使用的所有文本文档)的数据更好地存储在Nosql文档模型中。数据行为像excel电子表格，并适合行在行和受聚合计算更好地存储在一个sql数据库，其中postgresql只是几个好的选择之一。

您可能考虑的第三个选项是redis(http://redis.io/)，这是一个简单的键值数据存储，当查询像sql但不是刚性类型时，它非常快。

你举的例子似乎是一个简单的行/列类型问题。您会发现sql语法比MongoDB的查询语法少得多。 Node有很多东西可以推荐它，并且工具集在过去一年里已经显着成熟。我建议使用monogoose npm包，因为它减少了本地mongodb所需的样板代码的数量，我没有注意到任何性能下降。

http://slashdot.org/topic/bi/sql-vs-nosql-which-is-better/

http://www.infoivy.com/2013/07/nosql-database-comparison-chart-only.html

我有一些在 PHP中运行正常的代码.
从postgres CLI我发出一个

NOTIFY job;

Postgres正确引发了通知(我可以在PHP客户端中看到它),
但无法在节点中读取它.

JS：

var pg = require('pg');
var conString = "your postgres information";
var client = new pg.Client(conString);

client.connect();
client.query('LISTEN job');
client.on('notification',function(msg) {
    console.log('data');
});

我宁愿保持简单.是制作的唯一方法
postgres中的程序如this？

好的,问题出在conString参数中.

var conString = "tcp://user:pass@localhost/db";

检查您是否使用正确的数据库来访问通知消息非常重要.

我在使用pg( https://github.com/brianc/node-postgres)的nodejs中有以下代码
我为员工创建订阅的代码就是这样.

client.query(
      'INSERT INTO subscriptions (subscription_guid,employer_guid,employee_guid) 
       values ($1,$2,$3)',[
        datasetArr[0].subscription_guid,datasetArr[0].employer_guid,datasetArr[0].employee_guid
      ],function(err,result) {
        done();

        if (err) {
          set_response(500,err,res);
          logger.error('error running query',err);
          return console.error('error running query',err);
        }

        logger.info('subscription with created');
        set_response(201);

      });

您已经注意到datasetArr是一个数组.我想一次为多个员工创建大量订阅.但是我不想循环遍历数组.有没有办法用pg开箱即用？

我搜索了同样的问题,但还没有找到解决方案.
使用异步库,可以非常简单地多次使用查询,并进行必要的错误处理.

可能是这个代码变体有帮助.
(用于将10.000个小json对象插入空数据库,花费6秒).

克里斯托夫

function insertData(item,callback) {
  client.query('INSERT INTO subscriptions (subscription_guid,employee_guid)
       values ($1,[
        item.subscription_guid,item.employer_guid,item.employee_guid
       ],result) {
    // return any err to async.each iterator
    callback(err);
  })
}
async.each(datasetArr,insertData,function(err) {
  // Release the client to the pg module
  done();
  if (err) {
    set_response(500,res);
    logger.error('error running query',err);
    return console.error('error running query',err);
  }
  logger.info('subscription with created');
  set_response(201);
})

我刚开始使用node.js与postgres,使用node-postgres.我试图做的一件事是写一个简短的js来填充我的数据库,使用一个约20万条目的文件.

我注意到,有一段时间(少于10秒),我开始得到“错误：连接终止”.我不知道这是如何使用节点postgres,或者是因为我是垃圾邮件postgres问题.

无论如何,这里是一个简单的代码,显示这个行为：

var pg = require('pg');
var connectionString = "postgres://xxxx:xxxx@localhost/xxxx";

pg.connect(connectionString,function(err,client,done){
  if(err) {
    return console.error('Could not connect to postgres',err);
  }

  client.query("DROP TABLE IF EXISTS testDB");
  client.query("CREATE TABLE IF NOT EXISTS testDB (id int,first int,second int)");
  done();

  for (i = 0; i < 1000000; i++){
    client.query("INSERT INTO testDB VALUES (" + i.toString() + "," + (1000000-i).toString() + "," + (-i).toString() + ")",result){
      if (err) {
         return console.error('Error inserting query',err);
      }
      done();
    });
  }
});

约18,000-20,000次查询失败.这是使用client.query的错误方式吗？我尝试更改默认客户端号码,但似乎没有帮助.

client.connect()似乎也没有帮助,但那是因为我有太多的客户端,所以我绝对认为客户端池是要走的路.

感谢任何帮助！

为了复制您的场景,我使用了 pg-promise库,我可以确认尝试它将永远不会工作,无论您使用哪个库,这是重要的方法.

下面是一个修改的方法,我们将插入块分成块,然后在事务中执行每个块,这是负载平衡(也称为节流)：

function insertRecords(N) {
    return db.tx(function (ctx) {
        var queries = [];
        for (var i = 1; i <= N; i++) {
            queries.push(ctx.none('insert into test(name) values($1)','name-' + i));
        }
        return promise.all(queries);
    });
}
function insertAll(idx) {
    if (!idx) {
        idx = 0;
    }
    return insertRecords(100000)
        .then(function () {
            if (idx >= 9) {
                return promise.resolve('SUCCESS');
            } else {
                return insertAll(++idx);
            }
        },function (reason) {
            return promise.reject(reason);
        });
}
insertAll()
    .then(function (data) {
        console.log(data);
    },function (reason) {
        console.log(reason);
    })
    .done(function () {
        pgp.end();
    });

在大约4分钟内产生了1000,000条记录,在前3次交易之后大幅放缓.我正在使用节点JS 0.10.38(64位),消耗大约340MB的内存.这样我们插入了10万条记录,连续10次.

如果我们这样做,只有这一次在100个事务中插入10,000个记录,在1个25分钟内添加相同的1,000,没有减慢,Node JS消耗大约100MB的内存,这告诉我们这样的分区数据是非常好主意.

使用哪个图书馆并不重要,方法应该是一样的：

>分割/将您的插入调整为多个事务;
>将单个事务中的插入列表保留在大约10,000条记录中;
>在同步链中执行所有交易.
>在每个事务的COMMIT之后释放连接回到池.

如果你违反了这些规则,那么你是有保障的.例如,如果您打破规则3,您的Node JS进程可能会快速运行内存,并抛出错误.我的例子中的规则4由图书馆提供.

如果您遵循这种模式,您不需要使用连接池设置来解决问题.

更新1

pg-promise的更新版本完美支持这样的场景,如下图所示：

function factory(index) {
    if (index < 1000000) {
        return this.query('insert into test(name) values($1)','name-' + index);
    }
}

db.tx(function () {
    return this.batch([
        this.none('drop table if exists test'),this.none('create table test(id serial,name text)'),this.sequence(factory),// key method
        this.one('select count(*) from test')
    ]);
})
    .then(function (data) {
        console.log("COUNT:",data[3].count);
    })
    .catch(function (error) {
        console.log("ERROR:",error);
    });

如果你不想添加任何额外的东西,如表创建,那么它看起来更简单：

function factory(index) {
    if (index < 1000000) {
        return this.query('insert into test(name) values($1)','name-' + index);
    }
}

db.tx(function () {
    return this.sequence(factory);
})
    .then(function (data) {
        // success;
    })
    .catch(function (error) {
        // error;
    });

详见Synchronous Transactions.

例如,使用Bluebird作为承诺库,我的生产机器需要1m43,以插入1,000条记录(不启用长堆栈跟踪).

你可以根据索引让你的工厂方法返回请求,直到你没有剩下,简单的.

而最好的部分,这不仅仅是快速,而且对您的NodeJS进程造成了很小的负担.内存测试过程在整个测试期间保持在60MB以下,仅占cpu时间的7-8％.

更新2

从1.7.2版开始,pg-promise轻松支持超大规模的交易.参见第Synchronous Transactions章.

例如,我可以在我的家庭电脑,Windows 8.1 64位的15分钟内,在一个事务中插入10,000条记录.

对于测试,我将PC设置为生产模式,并使用Bluebird作为承诺库.在测试期间,对于整个NodeJS 0.12.5进程(64位),内存消耗没有超过75MB,而i7-4770 cpu显示出一致的15％负载.

以相同的方式插入100m记录将需要更多的耐心,但不会更多的计算机资源.

与此同时,以前的1m插入测试从1m43s降至1m31s.

更新3

以下考虑可以产生巨大的区别：Performance Boost.

更新4

相关问题,有较好的实施例子：
Massive inserts with pg-promise.