public LineItem(Product product, int quantity)
{
ProductId = product.Id;
ProductName = product.Name;
ProductUnitCost = product.UnitCost;
Quantity = quantity;
LineItemCost = Quantity * ProductUnitCost;
}
static void Main(string[] args)
{
IDocumentStore ravenStore = new DocumentStore() { DefaultDatabase = databaseName, Url = "http://localhost:8080" };
ravenStore.Initialize();
#region Empty Database (Pay no attention to the man behind the curtain)
// delete all existing documents
ravenStore.DatabaseCommands.DeleteByIndex("Raven/DocumentsByEntityName",
new IndexQuery
{
Query = "Tag:*"
}, allowStale: false);
// Delete the hilo docs to reset numbering
ravenStore.DatabaseCommands.Delete("Raven/Hilo/products", null);
ravenStore.DatabaseCommands.Delete("Raven/Hilo/invoices", null);
ravenStore.DatabaseCommands.Delete("Raven/Hilo/employees", null);
ravenStore.DatabaseCommands.Delete("Raven/Hilo/suppliers", null);
// Delete indexes
ravenStore.DatabaseCommands.DeleteIndex("Products/BySupplierName");
ravenStore.DatabaseCommands.DeleteIndex("ProductTotals/Invoiced");
ravenStore.DatabaseCommands.DeleteIndex("Suppliers/ByAttribute");
#endregion
#region Introduction to Storing and Retrieving typed objects
// Raven implements the unit of work pattern with IDocumentSession
using (IDocumentSession session = ravenStore.OpenSession())
{
// Product has an Id property, but we don't set it (Raven will do it for us)
Product widget = new Product()
{
Name = "Widget",
UnitCost = 3.49,
QuantityOnHand = 1000,
SupplierName = "Widgets 'r Us",
LastOrderDate = DateTime.UtcNow.AddDays(-33),
WarehouseAddress = "490 Boston Post Rd, Sudbury, MA"
};
// Passing the object into the session's Store method - you guessed it - stores the document
// signatures: Store(dynamic toStore), Store(object toStore)
session.Store(widget);
Product whatzit = new Product()
{
Name = "Whatzit",
UnitCost = 44.99,
QuantityOnHand = 180,
SupplierName = "House of Whatzits",
LastOrderDate = DateTime.UtcNow.AddDays(-19),
WarehouseAddress = "490 Boston Post Rd, Sudbury, MA"
};
session.Store(whatzit);
// We can see in the console that we haven't actually communicated with the RavenDb service yet.
// What do you think the ID of the Product we just added is?
// By default, RavenDb uses the HiLo algorithm to provide each session with a set of ids that can be freely used.
// A new set of Ids is negotiated between the session and the server if a session's batch is expended.
// Default Id format is "collectionName/docNumber"; Raven default is to use the plural entity type name as the collection name
// "Collection" is only a convention, not an enforced rule.
// completely possible for a Genre to be stored with Id "artists/99" that will be presented in the artists collection
// RavenDb _only stores documents_, as such collection is not a first class citizen in Raven.
// collection is a convenience that groups _potentially_ similar documents within the management studio (can also be used to query for docs)
// Id can also be numeric/Guid. Strong-typed in C# entity, RavenDb automatically does conversion to/from string when ser/des
// Id can be assigned to any string value. Can also plug-in custom id generators.
// Can we load by Id?
var loadedWidget = session.Load<Product>("products/1");
// Will query return the Product?
var queriedWidget = session.Query<Product>()
.Where(g => g.Name == "Widget")
.FirstOrDefault();
// SaveChanges makes a single remote call write the batch to the RavenDb server
session.SaveChanges();
// Session is "safe by default":
// * If a page size of query isn't specified (think Linq's "Take(x)" method), max of 128 results (configurable) are returned.
// Hard limit of 1024 (configurable) set on the server
// * A session is limited to 30 remote calls (configurable). If RavenDb is being used "properly", the number of remote calls
// executed within a session should be as close to 1 as possible. If more than 30 calls are being made, the code is probably
// in an N+1 situation
// Different results once changes have been saved?
queriedWidget = session.Query<Product>()
.Where(g => g.Name == "Widget")
.FirstOrDefault();
// Queries are executed against the Lucene indexes that RavenDb maintains. Even though entities can be loaded immediately after
// they've been stored in the session, they won't be included in queries until they've been saved to the RavenDb server. Promotes
// proper unit of work, IMO.
}
#endregion
#region References
// As a document store, the prefered mechanism is embedding references; simply store a copy of the data with the entity being stored.
// This works great for unchanging entities beneath an "aggregate root". For example, a line item of an invoice. The invoice is the
// aggregate root, and it contains many line items.
// Line items are immutable (cost of an item on an invoice won't change over time), and line items would only be
// accessed via the invoice, not directly. No need to have a separate line item document; embed it right in the invoice.
// Convenient, but not always appropriate. Ex: Referenced data changes frequently; would need to update all copies everywhere.
// Also, perhaps the aggregate root only requires a subset of the data; perhaps just enough to display on a web page.
// A line item is generated for the sale of a product. Product entities could track a lot of information (supplier, order history,
// warehouse location, etc) that an invoice doesn't directly care about. In this situation, the line item could contain a reference
// to the Product, and keep a copy of the product's Name and Unit Cost.
// This way, the Invoice has enough information about the product to display the line item, but because it also has the Id reference,
// the Product can be loaded if additional details are required.
using (IDocumentSession session = ravenStore.OpenSession())
{
var invoice = new Invoice()
{
DateUtc = DateTime.UtcNow,
LineItems = new List<LineItem>()
};
// Load all the products
var products = session.Load<Product>(1, 2) // Applies conventions for the entity to generate the full id
.ToList();
// create a line item for each product in this invoice
invoice.LineItems.Add(new LineItem(products[0], 11));
invoice.LineItems.Add(new LineItem(products[1], 3));
session.Store(invoice);
session.SaveChanges();
}
using (IDocumentSession session = ravenStore.OpenSession())
{
var invoice = session.Load<Invoice>("invoices/1");
// Each line-item in the invoice has basic product data, as well as the product id
// Using the product ids, we can get the products
var prods = new List<Product>();
foreach (var lineItem in invoice.LineItems)
{
prods.Add(session.Load<Product>(lineItem.ProductId));
}
// There's that N+1 situation we've been trying to avoid. We can do better
}
using(IDocumentSession session = ravenStore.OpenSession())
{
var invoice = session.Load<Invoice>("invoices/1");
var products = session.Load<Product>(invoice.LineItems.Select(li => li.ProductId)).ToList();
// 2 calls to RavenDb. No more N+1, but... we can do even better
}
using (IDocumentSession session = ravenStore.OpenSession())
{
var invoice = session
.Include<Invoice>(i => i.LineItems.Select(li => li.ProductId))
.Load("invoices/1");
var products = session.Load<Product>(invoice.LineItems.Select(li => li.ProductId)).ToList();
// Invoice and related products loaded in one remote call
}
// Unlike EF (and other ORMs), there's no concept of a navigation property. RavenDb forces the dev to explicitly
// load related entities.
#endregion
#region Dynamic Entities
using (IDocumentSession session = ravenStore.OpenSession())
{
// We added a document with Id manual/1 in Raven Studio.
dynamic empl = new ExpandoObject();
empl.FirstName = "Seth";
empl.LastName = "Richards";
empl.Id = "employees/1";
session.Store(empl);
session.SaveChanges();
}
using (IDocumentSession session = ravenStore.OpenSession())
{
dynamic empl = session.Load<dynamic>("employees/1");
session.Delete<dynamic>(empl);
session.SaveChanges();
}
#endregion
#region Indexes
// Executing a query against a session generates a temporary Dynamic Index.
// The first time a query is executed, a Lucene index is created. This can be an
// _expensive_ process, depending on complexity and document volume.
// If the same temporary index is queried enough times, Raven will automatically
// promote it to a permanent index.
// Static indexes are defined explicitly and provide far more capability. Because they're
// pre-defined, they can also greatly reduce (or eliminate) the latency encountered
// on first query.
ravenStore.DatabaseCommands.PutIndex("Products/BySupplierName",
new IndexDefinitionBuilder<Product>{
Map = prods => from prod in prods
select new { SupplierName = prod.SupplierName }
});
using (IDocumentSession session = ravenStore.OpenSession())
{
var fromWidgets = session.Query<Product>("Products/BySupplierName")
.Where(x => x.SupplierName == "Widgets 'r Us")
.ToList();
}
// Can also aggregate data using map/reduce
// Add a few more invoices
using (IDocumentSession session = ravenStore.OpenSession())
{
var prods = session.Load<Product>(1, 2).ToList();
session.Store(
new Invoice()
{
LineItems = new List<LineItem>(){ new LineItem(prods[0], 7), new LineItem(prods[1], 1)}
}
);
session.Store(
new Invoice()
{
LineItems = new List<LineItem>() { new LineItem(prods[0], 11) }
}
);
session.Store(
new Invoice()
{
LineItems = new List<LineItem>() { new LineItem(prods[1], 5) }
}
);
session.SaveChanges();
}
IndexCreation.CreateIndexes(typeof(ProductTotals_Invoiced).Assembly, ravenStore);
using (IDocumentSession session = ravenStore.OpenSession())
{
var totals = session.Query<ProductTotals>("ProductTotals/Invoiced").ToList();
var bigTotals = session.Query<ProductTotals>("ProductTotals/Invoiced")
.Where(pt => pt.TotalSaleCost > 300.0)
.ToList();
}
#endregion
#region Indexes on Entities with dynamic schema
using (IDocumentSession session = ravenStore.OpenSession())
{
var s1 = new Supplier()
{
Attributes = new List<SupplierAttribute>()
{
new SupplierAttribute("Name", "Widgets 'r Us"),
new SupplierAttribute("President", "John Jones"),
new SupplierAttribute("Address", "123 Main Street, Beverly Hills, CA 90210")
}
};
session.Store(s1);
var s2 = new Supplier()
{
Attributes = new List<SupplierAttribute>()
{
new SupplierAttribute("Name", "Whozits 4 U"),
new SupplierAttribute("President", "Mike Miller"),
new SupplierAttribute("Address", "456 Main Street, Springfield, IL 55342"),
new SupplierAttribute("VicePresident", "Sue Sanderson"),
}
};
session.Store(s2);
session.SaveChanges();
}
using (IDocumentSession session = ravenStore.OpenSession())
{
var suppliersOnMainStreet = session.Advanced.LuceneQuery<Supplier>("Suppliers/ByAttribute")
.Where("Address:*Main?Street*")
.ToList();
var sueIsVP = session.Advanced.LuceneQuery<Supplier>("Suppliers/ByAttribute")
.WhereEquals("VicePresident", "Sue Sanderson")
.ToList();
}
#endregion
}