ravendb / ravendb Goto Github PK

Probably the same for indexes as well.

Need to show some error on that

That is when we are using the new default documentations

We currently don't do that, and it is a good optimization

So we can host raven on:
http://+/:8080/raven

other wise, there is no indication that something happened.

Allow to define meta data about a document (using headers)
Saying who are the users/groups allows to see it

This requires us to have user/groups
And requires us to have authentication

If an index cause more than 10% failures (exceptions on indexes), it probably means that it is faulty, and we should disable it.
Disabled indexes cannot be queried and would require re-definition to be of use.

Right now it only supports Map, should support Map, Reduce, Indexes and Stores.

Should be able to POST a list of document ids to the server and get back their content.

Should manage the etag internally

number of requests
number of puts, gets, deletes
number of queries
avg request time
longest request url

where longest means took the most time
biggest request url, where biggest means the db sent the most data

required so we would allow the users to define indexing behavior.

Should be able to define a set of servers to use as the sources, and shard between them automatically.

When a task is added, should look for existing tasks of the same type on the same index/view and merge it with them.
Should increase perf some.

We get a message back from the server
Right now it ignores it.

Simple numbers:
Number of total indexed documents (including re-indexing).
Number of failed indexing attempts (threw an exception)

A simple xml /json file specifying;

• data dir
• log level
• port
• virtual directory

from post in docs.posts
select new {
post.blog_id,
comments_length = comments.length
};

from agg in results
group agg by agg.key into g
select new {
agg. blog,
comments_length = g.Sum(x=>x.comments_length)
};

http://groups.google.com/group/rhino-divandb/web/raven--views-aggregation-design

Use etag as the version

Something simple, that can make writing data to RDB easy
Implement UoW ?

Similar to what we do with /docs

Right now, visiting this URL shows no error:
http://localhost:8080/raven/view.html?docId=raven_documentation/docs_http_api_get2

It should show something.

/indexes/UsersAndProjects?sort_ascending=project&sort_descending=name <- sort by project ascending, name descending

Think about finding better names for the query params

Right now we aren't supporting this.

Put this in the raw json format
{"name":"ayende","email":"[email protected]","projects":[{"name":"raven"}]}

Move to the json editor, try to open the projects node, see that you see nothing, switch back to raw json, and you see the projects are gone.

POST /docs/users/

will result in:

{"Key": "users/483" }

Just need to wire it up

Need to add support for it

So we can support "migration" style queries like:

from doc in docs
where doc.type == "post"
select new
{
type = doc.type,
content = doc.content,
posted_at = doc.posted_at,
categories = new [] { doc.category }
}

Should run at the server side, not client side, and the output overwrite the current document.

I can select an index, but i can't seem to input the query

Right now I don't think this is the case, jquery.RavenDB.js may not be included.

The folowing JSON doesn't work:
{'name':'ayende','email':'[email protected]','projects':[{'name':'raven'}]}

when user puts in bad json in the raw view, there is no error, but things stops working.

Can easily check that using Json comparer.

Not a RESTful operation, but required.

The simplest is to create
Put( Doc [] docs)

And then to have something like;

/bulkdocs - where post accepts an array of documents and save them in a single transaction The format could be;

[ { method: "PUT", data: { the actual doc }, metadata: { meta }, key: key }, { method: "DELETE", key: key } }

So we can do partial document updates

Run as debug by default / console
-service << run as service -install << install service -uninstall << remove service

So we wouldn't request them all the time

posting to /queries

We changed the format

There are more information there, we should show it

Allow to see documents, see queries, execute queries, add queries , update queries, remove queries, edit documents.
Should be self contained as a simple HTML + JS app working against the server.

Need to consider regular index & mapreduce views

We currently don't have that

One of the comments that I heard was that DTC support would be important for several key scenarios (such as using Raven with Rhino Service Bus, or any queuing implementation).
We should implement a DTC support using System.Transactions.

No reason to write my own dialect of the bloody thing if C# 4.0 gives it for free

Instead of getting full document back, allow a way to specify some of the fields that you want to be retrieved directly from the index.

So that if a function throw, it will only effect the current document, nothing else.

Where they can see things like errors from index functions