Your SlideShare is downloading. ×
Introduction to RavenDB
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Introduction to RavenDB

2,182
views

Published on

Visual Studio Live presentation on RavenDB. Introduces the concept of NoSQL databases and then takes you on a quick tour of the RavenDB .NET SDK - simple LINQ queries, loading related documents, …

Visual Studio Live presentation on RavenDB. Introduces the concept of NoSQL databases and then takes you on a quick tour of the RavenDB .NET SDK - simple LINQ queries, loading related documents, dynamic and static indexes, and full-text search with Lucene and query suggestions.

Published in: Technology

0 Comments
2 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
2,182
On Slideshare
0
From Embeds
0
Number of Embeds
23
Actions
Shares
0
Downloads
18
Comments
0
Likes
2
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Seeking Life Beyond Relational: RavenDB Sasha Goldshtein CTO, Sela Group Level: Intermediate
  • 2. NoSQL • The Zen-like answer: No one can tell you what NoSQL is, they can only tell you what it isn’t • It doesn’t use SQL It usually is less consistent than RDBMS It doesn’t put an emphasis on relations It emphasizes size and scale over structure • • •
  • 3. Classes of NoSQL Databases Document DB KeyValue DB Column DB Graph DB
  • 4. RavenDB • • • • • • • • Transactional document database Oren Eini (Ayende Rahien) Open source https://github.com/ravendb/ravendb with licensing for commercial projects Schema-less documents, JSON storage RESTful endpoints LINQ-style .NET API Implicit (usage-based) or explicit indexing Powerful text search based on Lucene Replication and sharding support
  • 5. Hosting RavenDB • • • • • Raven.Server.exe Windows Service Integrated in IIS Embedded client for stand-alone apps Cloud-hosted (e.g. RavenHQ)
  • 6. Management Studio
  • 7. RavenDB Management Studio DEMO
  • 8. Opening a Session • • DocumentStore is the session factory; one per application is enough Supports .NET connection strings or direct initialization: var ds = new DocumentStore { Url = "http://localhost:8888" }; ds.Initialize();
  • 9. CRUD Operations on Documents • Unit of work pattern (ORM-style) using (var session = documentStore.OpenSession()) { session.Store(new Speaker(“Sasha”, “Tel-Aviv”)); session.SaveChanges(); } using (var session = documentStore.OpenSession()) { Speaker sasha = session.Query<Speaker>() .Where(e => e.City == “Tel-Aviv”).First(); sasha.City = “Orlando”; session.SaveChanges(); }
  • 10. Collections and IDs • • • • Documents are stored in JSON format Documents have metadata that includes the entity type A collection is a set of documents with the same entity type Documents have unique ids, often a combination of collection name + id – speakers/1 – conferences/7
  • 11. Basic Operations DEMO
  • 12. Modeling Data as Documents • Don’t be tempted to use a document store like a relational database – Documents should be aggregate roots – References to other documents are OK but (some) data duplication (denormalization) is also OK “conference/11” : { tracks: [ { title: “Web”, days: { 1, 2 }, sessions: [ ... ] }, ... ] Should the tracks be } references?
  • 13. …But Don’t Go Too Far • Is this a reasonable document? “blogs/1” : { tags : [ “Windows”, “Visual Studio”, “VSLive” ], posts : [ My blog has 500 posts { title: “Migrating to RavenDB”, content: “When planning a migration to Raven…”, author: “Sasha Goldshtein”, comments: [ ... ] ... }, ... ] }
  • 14. One More Example “orders/1783”: { customer: { name: “James Bond”, id: “customers/007” }, items: [ { product: “Disintegrator”, cost: 78.3, qty: 1 }, { product: “Laser shark”, cost: 99.0, qty: 3 } ] } What if we always need to know whether the product is in stock? What if we always need the customer’s address? What if the customer’s address changes often?
  • 15. Include • Load the referenced document when the referencing document is retrieved – Also supports arrays of referenced documents Order order = session.Include<Order>(o => o.Customer.Id) .Load(“orders/1783”); Customer customer = session.Load<Customer>( order.Customer.Id); Order[] orders = session.Query<Order>() .Customize(q => q.Include<Order>(o => o.Customer.Id)) .Where(o => o.Items.Length > 5) .ToArray();
  • 16. Include and Load DEMO
  • 17. Indexes • RavenDB automatically creates indexes for you as you run your queries – The indexing happens in the background after changes are made to the database – Indexes can become stale – Can wait for non-stale results (if necessary) RavenQueryStatistics stats; var results = session.Query<Speaker>() .Statistics(out stats) .Where(s => s.Experience > 3) .ToArray(); if (stats.IsStale) ...
  • 18. ACID? • If indexes can become stale, does it mean RavenDB is not ACID? • The document store is ACID The index store is not • • You can insert lots of data very quickly and load it quickly, but indexes take a while to catch up
  • 19. Indexing Fundamentals • • A document has fields that are indexed individually An index points from sorted field values to matching documents Customer Document IDs "orders/1" : { customer: "Dave", price: 200, items: 3 } Dave orders/1, orders/3 Mike orders/2 "orders/2" : { customer: "Mike", price: 95, items: 1 } Price Document IDs 95 orders/2 150 orders/3 200 orders/1 "orders/3" : { customer: "Dave", price: 150, items: 2 }
  • 20. Static (Manual) Indexes • • Static indexes can provide map and reduce functions to specify what to index The simplest form specifies a map function with the fields to index: ds.DatabaseCommands.PutIndex(“Speaker/ByCity”, new IndexDefinitionBuilder<Speaker> { Map = speakers => from speaker in speakers select new { speaker.City } } );
  • 21. Hierarchical Data • How to index the following hierarchy of comments by author and text? public class Post { public string Title { get; set; } public Comment[] Comments { get; set; } } public class Comment { public string Author { get; set; } public string Text { get; set; } public Comment[] Comments { get; set; } }
  • 22. Hierarchical Index with Recurse public class CommentsIndex : AbstractIndexCreationTask<Post> { public CommentsIndex() { Map = posts => from post in posts from comment in Recurse(post, c=>c.Comments) select new { Author = comment.Author, Text = comment.Text } } } This is an index over Post objects but the output produces Comment objects!
  • 23. Map/Reduce Index • We often need the speaker count for each of our conferences: class SpeakerCount : Tuple<string, int> {} ds.DatabaseCommands.PutIndex(“Conferences/SpeakerCount”, new IndexDefinitionBuilder<Conference, SpeakerCount> { Map = conferences => from conf in conferences from speaker in conf.Speakers select new { Item1 = speaker.Name, Item2 = 1 }, Reduce = results => from result in results group result by result.Item1 into g select new { Item1 = g.Key, Item2 = g.Sum(x => x.Item2) } } );
  • 24. Using Indexes • • In most cases you simply run a query and it will implicitly use or create an index Or, instruct the query to use your index: var d = session.Query<SpeakerCount>(“Conferences/SpeakerCount”) .FirstOrDefault(s => s.Item1 == “Dave”); Console.WriteLine(“Dave spoke at {0} conferences”, d.Item2); var posts = session.Query<Comment>(“CommentsIndex”) .Where(c => c.Author == “Mike”) .OfType<Post>();
  • 25. Indexing Related Documents Use the LoadDocument method • session.Query<OrderCustomerCityIndex.Result, OrderCustomerCityIndex>() public class OrderCustomerCityIndex : .Where(c => c.City == “Orlando”) AbstractIndexCreationTask<Order, OrderCustomerCityIndex.Result> .OfType<Order>() .ToList(); { public class Result { public string City; } public OrderCustomerCityIndex() { Map = orders => from order in orders select new { City = LoadDocument(order.Customer.Id).City } } }
  • 26. Using Indexes DEMO
  • 27. Full-Text Search Indexes Made possible by the underlying Lucene.NET engine • public class SpeakerIndex : AbstractIndexCreationTask<Speaker> { public SpeakerIndex() { Map = speakers => from speaker in speakers select new { speaker.Name }; Index("Name", FieldIndexing.Analyzed); } }
  • 28. Using Full-Text Search and Query Suggestions var query = session.Query<Speaker, SpeakerIndex>() .Where(s => s.Name == name); var speaker = query.FirstOrDefault(); Will find “Dave Smith” when searching for “dave” or “smith” if (speaker == null) { Will suggest “dave” when searching for “david” string[] suggestions = query.Suggest().Suggestions; }
  • 29. Using Lucene Directly • • You can also query Lucene directly on any analyzed fields E.g., fuzzy search for sessions: string query = String.Format("Title:{0}*", term); session.Advanced.LuceneQuery<Session>("SessionIndex") .Where(query) .ToList();
  • 30. Full-Text Search and Suggestions DEMO
  • 31. Advanced Features • • • • • • • Batch operations by index Async API (OpenAsyncSession, await) Attachments Patching (partial document updates) Change notifications (IDatabaseChanges) Transactions (TransactionScope) …and many others http://ravendb.net/docs
  • 32. Upcoming Features in RavenDB 3.0 • • • • Management Studio rewrite in HTML5 Web API-based infrastructure First-class Java client SDK Custom storage engine (Voron)
  • 33. Thank You! Sasha Goldshtein @goldshtn blog.sashag.net

×