标签: nosql

我目前正在尝试为自己编写一个备份/同步系统（Dropbox 等不为我的目的而削减它），我想我已经确定了最好的方法。

问题是，使用关系数据库（如我刚刚添加到我的 .Net 4 项目中的本地数据库）将是疯狂的，除非我将它分解成一堆荒谬的表，并可能在运行时修改数据库。

我希望有人能够将我指向一个内置于 .Net 的 no-rel/nosql DB，它不需要其他正在运行的进程（例如，从平面文件中工作，也许？）但是由于这个项目的性质，它会变大。像GB一样大。（我必须存储每个文件的最新版本，+ 历史差异）。

谢谢你的时间。

PS 像 MongoDB 这样的东西对我有用，但我相信其他 NoSQL 风格也可以。

[编辑以获取更多详细信息]

看到这个项目将被用作本地备份系统，我正在寻找一个不需要运行进程等的数据库系统。不幸的是，这排除了 RavenDB。

此外，在某些情况下，数据库的大小将超过 RAM。据我了解，这排除了 dbo4。

[/编辑]

我有两个型号:

Item.js

const mongoose = require('mongoose');

const itemSchema = new mongoose.Schema({
   name: String,
   stores: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Store' }]
});

const Item = mongoose.model('Item', itemSchema);

module.exports = Item;

Store.js

const mongoose = require('mongoose');

const storeSchema = new mongoose.Schema({
   name: String,
   items: [{ type: mongoose.Schema.Types.ObjectId, ref: 'Item' }]
});

const Store = mongoose.model('Store', storeSchema);

module.exports = Store;

还有一个seed.js文件:

const faker = require('faker');
const Store = require('./models/Store');
const Item = require('./models/Item');

console.log('Seeding..');

let item = new Item({
   name: faker.name.findName() …

我有一系列字典，必须在上面进行查询。查询将类似于“名称”为“ a”，然后“值”应为“ 2”。

{
    "t": "m",
    "y": "n",
    "A":[ 
            {
             "name": "x",
             "value": "1"
            },
            {
             "name": "y",
             "value": "2"
            },
            {
             "name": "z",
             "value": "1"
            }
        ]
}

在上面，我想知道什么是“名称”为x时“值”为“ 1”的记录。我还需要进行类似的查询，其中“名称”为“ x”，然后值应为“ 2”，“名称”为“ y”，然后“值”应为“ 1”

我正在尝试创建一个WriteBatch来控制我的数据库中的一个动态引用.我的应用程序有一个简单的User-Follow-Post-Feed模型,我希望我的用户在他的Feed中查看他所关注的所有用户的帖子.在研究Firebase示例(作为Firefeed)和Stack Overflow上的大量帖子后,我正在做什么.

最佳的想法是保持一个路径(collection在这种情况下)我存​​储Ids我的用户应该在他的Feed中看到的帖子,这意味着保持对副本的控制并删除他关注/取消关注的所有用户的每个帖子.

我让我Cloud functions以原子的方式保持这一点,并且一切正常,但当我尝试进行大规模测试时,为用户添加超过5000个帖子试图跟随他(寻找Cloud function需要花多少时间)),我看到批次限制为500次操作.所以我所做的就是将我的5000个id分成多个小列表,每个列表执行一个批处理,永远不会超过500个限制.

但即使这样做,我仍然会得到一个错误I can't do more than 500 operations in a single commit,我不知道是否因为批次同时执行,或者为什么.我想也许我可以一个接一个地连接,并避免一次性执行它们.但我仍然有一些麻烦.这就是我提问的原因.

这是我的方法:

 fun updateFeedAfterUserfollow(postIds: QuerySnapshot, userId: String) {
        //If there is no posts from the followed user, return
        if (postIds.isEmpty) return
        val listOfPostsId = postIds.map { it.id }
        val mapOfInfo = postIds.map { it.id to it.toObject(PublicUserData::class.java) }.toMap()

        //Get User ref
        val ref = firestore.collection(PRIVATE_USER_DATA).document(userId).collection(FEED)
        //Split the list in …

使用Couchbase 5.0及其Java客户端2.0.3,我有以下错误.

只需按照这些说明打开一个桶:

https://developer.couchbase.com/documentation/server/current/sdk/java/managing-connections.html

如上所述,使用基本的本地配置,只需两行代码:

Cluster cluster = CouchbaseCluster.create();
Bucket bucket = cluster.openBucket("hero");

那应该打开localhost集群(实际上是这样)然后打开一个名为"hero"的存储桶,它实际存在于我的Couchbase服务器中.

不过,我一直收到以下错误:

2017-11-08 00:40:25.546 ERROR 1077 --- [nio-8080-exec-1] o.a.c.c.C.[.[.[/].[dispatcherServlet]    : Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is com.couchbase.client.java.error.InvalidPasswordException: Passwords for bucket "hero" do not match.] with root cause

com.couchbase.client.java.error.InvalidPasswordException: Passwords for bucket "hero" do not match.
    at com.couchbase.client.java.CouchbaseAsyncCluster$1.call(CouchbaseAsyncCluster.java:156) ~[java-client-2.0.3.jar:2.0.3]
    at com.couchbase.client.java.CouchbaseAsyncCluster$1.call(CouchbaseAsyncCluster.java:146) ~[java-client-2.0.3.jar:2.0.3]
    at rx.internal.operators.OperatorOnErrorResumeNextViaFunction$1.onError(OperatorOnErrorResumeNextViaFunction.java:77) ~[rxjava-1.0.4.jar:1.0.4]
    at rx.internal.operators.OperatorMap$1.onError(OperatorMap.java:49) ~[rxjava-1.0.4.jar:1.0.4]
    at rx.internal.operators.NotificationLite.accept(NotificationLite.java:147) ~[rxjava-1.0.4.jar:1.0.4]
    at rx.internal.operators.OperatorObserveOn$ObserveOnSubscriber.pollQueue(OperatorObserveOn.java:177) ~[rxjava-1.0.4.jar:1.0.4]
    at rx.internal.operators.OperatorObserveOn$ObserveOnSubscriber.access$000(OperatorObserveOn.java:65) ~[rxjava-1.0.4.jar:1.0.4] …

我目前正在研究我的NoSQL项目,我有两个数据库Cassandra和Redis(我使用Redis进行缓存).现在使用Redis我有一个列表,我使用DataContract序列化我的自定义对象,但是当涉及到Cassandra时,我正在努力,因为我试图以某种方式在Cassandra表中插入Guid,其中我使用uuid作为主键.我在互联网上搜索过,我所能找到的只是Guid是Cassandra的uuid数据类型.我已经在Cassandra中使用now()插入了uuid所以我想知道我是否可以以某种方式从C#调用now()或者如果我能以某种方式将Guid转换为uuid.非常感谢任何帮助或参考.谢谢.

假设我有一些汽车，我想按price范围和year范围过滤它们。我知道由于性能原因，Firestore具有严格的限制，因此类似：

db.collection("products")
  .where('price','>=', 70000)
  .where('price','<=', 90000)
  .where('year','>=', 2015)
  .where('year','<=', 2018)

会抛出一个错误：

查询无效。不等式（<，<=，>或> =）的所有过滤器都必须位于同一字段上。

那么，有没有其他方法可以执行这种查询而无需本地数据管理？也许是某种索引或棘手的数据组织？

我正在使用DynamoDB完成一个练习来模拟多对多的关系.我需要允许帖子和标签之间的多对多关系.每个帖子可以有很多标签,每个标签可以有很多帖子.

我有一个主键id和主排序关键字type,然后另一个全球指数id和data,我增加了另一个全球指数id和type再次,但我认为这是多余的.

这是我到目前为止所拥有的.

id(Partition key)      type(Sort Key)       target       data
-------------          ----------           ------       ------
1                      post                 1            cool post
tag                    tag                  tag          n/a
1                      tag                  tag          orange

---------------------------------------------
---- inserting another tag will overwrite ---
---------------------------------------------

1                      tag                  tag          green

我正在从这个精彩的演讲https://www.youtube.com/watch?v=jzeKPKpucS0和这些不那么棒的文档中获取建议https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency -graphs.html

我遇到的问题是,如果我尝试添加另一个带有id"1"和type"tag"的标记,它将覆盖现有标记,因为它将具有相同的复合键.我在这里错过了什么？看起来建议是将主键和排序键设为id和type.我的类型应该更像"tag#orange"吗？在这种情况下,我可以target在类型上使用排序键放置全局索引.通过查询target ="tag",我可以通过"tag"获取带有特定标签的所有帖子.

只是寻找一些关于使用Dynamo处理这种邻接列表数据的建议,因为它看起来非常有趣.谢谢!

使用javascript aws-sdk并通过文档客户端查询dynamodb表。该表包含10个元素，查询限制= 5。

对于每个请求，我使用LastEvaluatedKey生成一个新查询并发送一个新请求，结果如下：

first request --> {Items: Array(5), Count: 5, ScannedCount: 5, LastEvaluatedKey: {…}}
second request --> {Items: Array(5), Count: 5, ScannedCount: 5, LastEvaluatedKey: {…}}
third request --> {Items: Array(0), Count: 0, ScannedCount: 0}

根据这份文件

如果结果包含LastEvaluatedKey元素，请继续执行步骤2。 如果结果中没有LastEvaluatedKey，则没有其他要检索的项目

它应该在第二个请求中不返回LastEvaluatedKey，因为没有更多的元素，但是它在第三个请求中返回一个发送到空结果的元素。

当我尝试使用limit = 4时，一切都会按预期进行

first request --> {Items: Array(4), Count: 4, ScannedCount: 4, LastEvaluatedKey: {…}}
second request --> {Items: Array(4), Count: 4, ScannedCount: 4, LastEvaluatedKey: {…}}
third request --> {Items: Array(2), Count: 2, …

我有这个架构：

var orderSchema = new mongoose.Schema({
  history: [{
    "type": {
      type: String,
      enum: [
        'ORDER_HISTORY_DRIVER_DETAILS',
        'ORDER_HISTORY_LOADING',
        'ORDER_HISTORY_LOCATION',
        'ORDER_HISTORY_UNLOADING'
      ],
      required: true
    },
    date: {
      type: Date
    },
    state: {
      type: String,
      enum: [
        'ORDER_HISTORY_STEP_STATE_COMPLETED',
        'ORDER_HISTORY_STEP_STATE_CURRENT',
        'ORDER_HISTORY_STEP_STATE_FUTURE',
      ],
      default: 'ORDER_HISTORY_STEP_STATE_FUTURE',
      required: true
    }
  }]
})

有一次，我需要删除所有类型为“ ORDER_HISTORY_LOCATION”的子文档，因此我正在运行以下代码：

let result = await Order.findOneAndUpdate(
  {orderId: req.params.orderId},
  {
    $pull: {
      history: {type: "ORDER_HISTORY_LOCATION"}
    }
  }, {new: true}
);

当我登录“ result.history”时，我得到了：

CoreMongooseArray [
{ state: 'ORDER_HISTORY_STEP_STATE_CURRENT',
  _id: 5caf8a41641e6717d835483d,
  type: 'ORDER_HISTORY_DRIVER_DETAILS' },
{ state: 'ORDER_HISTORY_STEP_STATE_FUTURE',
  _id: …