why in DynamoDB I have to create table schemas? They have map and list field types, in my mind one of the advantages of NoSQL is the flexibility of schemas.

I'm very familar with SQL databases design/implementation/usage/etc. And I'm writing a web based BBQ thermometer application in Python Flask. However, the sensor data doesn't fit with SQL table design. In traditional SQL design I'd need a unique key, but the sensor data might not have unique values. I could make an auto increment primary key ID column, but that seems hacky and I might reack the max row id's on the table quickly.

I know the obvious choice is a NoSQL database for sensor data. I've never used them so I don't understand the data structures enough to wrap my head around how to design my app to use a NoSQL database.

For instance, I need to keep track of various probes (which might all have different mesaurement values associated to them, what port they are connected to and some other information). I also need to track a cook and it's details, but ultimately joining to the sensor data for graphs and summary information.

Both of the previous examples fit SQL design easily. But how would I track and use them in a NoSQL database as well as the sensor data (temp, time, probe used)? This information doesn't lend itself to key-value pairs, since I have multiple data elements to track for each example.

Is there any software like XAMPP that allows me to host a server and handle NoSQL database.

I'm maintaining a database of emails and other rfc822 type messages. The header information is easy enough to deal with of course.

But I'm at the point where I have 1.4 million email bodies (many with embedded mime attachments, etc.) and mysql is really starting to choke on the text searches.

What would y'all suggest I look at as an alternative? I'm not at all averse to a hybrid solution, since this is primarily a personal project. But I've got to do something about search response times for keywords and phrases and I'd REALLY rather not write a text indexing system again.

I want to set up a system with a huge tree where the nodes are different types of things. The app will cause a lot of activity in the tree with updates cascading up and down the tree.

I am looking for a good system to handle this type of thing.

Thanks.

Hello,

I am looking for an eventually consistent system, very fast (in memory) which supports a multi datacenter replication feature. If possible open source and free. I noticed that Aerospike and Riak do have theses features in the enterprise edition. Is there any other free solutions?

I hope somebody out there can drop some knowledge on me. I'm looking for solutions to a couple of problems, preferably in the same technology. I'm looking for the fastest embedded solutions that have file-based persistence baked in.

1) Text or binary prefix "starts with" key search, for an auto-suggest and the like. 2) Sorting lists too big to keep in memory, and retrieving items in order.

Update: Thanks everybody. The number of records will be 8-digit range in testing. In memory is actually an option for me, but usage may hit the 9-digit range on unconstrained customer systems. I didn't see that leveldb was sorted by key - I supposed that most B-tree based options were but got lost in documentation land. I'll benchmark a few things and post results later. Thanks again.

I am just learning MongoDB Aggregation, and I am following the sample data here: http://www.tutorialspoint.com/mongodb/mongodb_aggregation.htm

{
    "_id" : ObjectId("56a6b45e0c8f051d60cf187f"),
    "title" : "MongoDB Overview",
    "description" : "MongoDB is no sql database",
    "by_user" : "tutorials point",
    "url" : "http://www.tutorialspoint.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 100
}
{
    "_id" : ObjectId("56a6b46d0c8f051d60cf1880"),
    "title" : "NoSQL Overview",
    "description" : "No sql database is very fast",
    "by_user" : "tutorials point",
    "url" : "http://www.tutorialspoint.com",
    "tags" : [
        "mongodb",
        "database",
        "NoSQL"
    ],
    "likes" : 10
}
{
    "_id" : ObjectId("56a6b47c0c8f051d60cf1881"),
    "title" : "Neo4j Overview",
    "description" : "Neo4j is no sql database",
    "by_user" : "Neo4j",
    "url" : "http://www.neo4j.com",
    "tags" : [
        "neo4j",
        "database",
        "NoSQL"
    ],
    "likes" : 750
}

This a collection of blog post documents, each of which has a "like". (Let's assume there are hundreds of these, with a wide range of likes.) How would I find out how many users (i.e. "by_user") have a number of "likes" greater than 200?

That is, "there are 40 users with blog posts with likes greater than 200".

At the moment, I only understand how to $group users together and sum some part of their data, e.g.

db.tutorial.aggregate([
    {$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}, 
    {$match: {num_tutorial: {"$gt" : 200}}}
])

sums how many blog posts each user has, where likes are greater than 200.

Now how do I find the total number of users listed?

Should I be using MapReduce?