.NET Database Technologies. Entity Framework: Queries and Transactions

Transcription

1 .NET Database Technologies Entity Framework: Queries and Transactions

2 ORMs and query languages l With an ORM, queries must define data to be returned and criteria in terms of domain model objects and their properties l Framework translates object query to query understood by underlying data store (SQL) l Many query languages have been created for specific ORMs on.net and other platforms l e.g. HQL, JPQL, EJB QL, Entity SQL l Generally use magic strings 2

3 ORM query language examples l HQL (Hibernate, NHibernate) using (var tx = session.begintransaction()) { int count = (int) session.createquery("select count(*) from Trip").UniqueResult(); tx.commit(); } l Entity SQL 3

4 Language integrated queries l LINQ offers.net applications the capability to defined type-safe queries[1] l Compile-time checking and Intellisense l Not specific to ORMs, supported by providers for many data sources l Preferred way of defining queries in EF, supported by NHibernate and other.net ORMs l Other type-safe query languages have also been created/proposed, e.g. Native Queries supported in db4o object database[2] 4

5 LINQ l General-purpose query facilities for.net that apply to all sources of information, not just relational or XML data l Queries expressed using query syntax or standard query operators l EF supports LINQ to Entities 5

6 LINQ to Entities derived from DbContext type is DbSet, implements IQueryable extension methods, act on IQueryable and return IQueryable, methods defined in System.Linq.Queryable class deferred execution - query not sent to database until results are touched, e.g. by enumerating with foreach or returning results as List or array ToList forces execution Compare this to LINQ to Objects queries, which operate on IEnumerable, extension methods in System.Linq.Enumerable class 6

7 Lambda functions/expressions l Lambda expressions provide a compact syntax for authoring query operators l Lambda can represent a function or an expression l f is a reference to an executable delegate l e is a reference to an expression tree which is not directly executable 7

8 Expression trees l Expression tree is a data structure l Can be traversed and modified at runtime l Expression class or subclass properties (e.g. BinaryExpression, LambdaExpression): l Body l Parameters l Left/Right l NodeType l Type l Compile method converts to callable code 8

9 Expression trees Expression definition LambdaExpression LambdaExpression.Body is instance of BinaryExpression 9

10 Entity Framework expressions l LINQ to Entities expects Expression rather than Func for query operator, e.g. l Expression<Func<DomainType, bool>> is required for filtering with Where l Expression here is a predicate object that represents a query criterion l Expression<Func<DomainType, ResultType>> is required for Select 10

11 Entity Framework expressions l IQueryable has property of type Expression l Holds the expression tree for that instance l Tree is built from all the expressions which combine to define that query, including those used in Where, OrderBy, Select, etc. l Easier to translate a data structure into SQL than to translate executable code into SQL 11

12 Combining expressions l Can combine criteria in a query with chained calls to Where (not ideal) l Equivalent to: 12

13 Query object pattern l An object that represents a database query Fowler l A LINQ expression can be thought of as an implementation of the pattern l Quite closely follows Fowler s description l Arguably no need to implement your own 13

14 Query objects l However, it can be useful to design your own query objects at a higher level of abstraction l Can improve separation of concerns, e.g. remove query logic from repositories l Can create testable query logic useful if query is complex l One approach is to encapsulate parameter(s) as properties of QO class and provide method to return an expression[3] 14

15 Query object example l Query object class l Creating and using a query object 15

16 Composing expressions l Query Object pattern suggests the ability to build a single object composed of criteria l Arguably a LINQ query provides this, but we can also compose criteria explicitly before using in LINQ query l Expression tree can be manipulated at runtime, but this can be tricky l PredicateBuilder[4] makes this easier to do 16

17 Using PredicateBuilder l Need to download and have reference to LinqKit.dll AsExpandable method provided by LinqKit, required for EF queries 17

18 Composed query class l Rather than composing in client code we can build specific query class from simpler queries 18

19 Composed query class 19

20 Query object design l No single definitive way to design query objects l Many examples to be found l For example, some authors define queries as an additional set of extension methods on IQueryable l Some refer to Specification pattern l Design of queries and the way they are used, e.g. within or instead of repositories, is an important part of application architecture 20

21 LINQ queries compared to SQL l SQL operates on a relation and returns a relation l Need to explicitly JOIN associated entities l LINQ can return complex object graph l Can return domain objects l Can project to new anonymous object built from properties/objects returned by query l LINQ can navigate relationships between associated entities l Don t always need to use Join 21

22 Fetch strategy l Unless you are using lazy loading you need to consider fetch strategy carefully l Make sure any associated objects which client code needs are materialised l If not, can get null reference exceptions when accessing object members l Careful use of Include is required 22

23 Fetch strategy example l Use LinqPad to visualise results l No eager loading, Department only 23

24 Fetch strategy examples l Include Employees collection 24

25 Fetch strategy examples l Include Address property of each Employee 25

26 Division of responsibility l Query logic and fetch strategy are distinct responsibilities l Need to design an architecture which places these responsibilities in appropriate classes l Many different approaches possible l Look at examples later when we look more closely at repositories l Summarise one possible approach briefly here 26

27 Division of responsibility l Use query objects, or simply Expressions, to encapsulate query criteria l Expose domain objects to client through repository as IQueryable l Repository uses query objects, possibly passed from client as parameters l Client (e.g. MVC controller or service layer method) applies fetch strategy to result client knows what objects are required for the operation it needs to perform 27

28 Finding a single object with Find l Find is a method of DbSet by PK l Return type is Object, can t access associated objects unless already loaded l A round-trip to the database will only be made if the entity with the given key is not found in the context l Find will return entities that are in the Added state, i.e. Find will return entities that have been added to the context but have not yet been saved to the database 28

29 Find examples 29

30 Native SQL queries l Most ORMs allow SQL or calls to stored procedures to be sent to database native (to database) query l EF allows SQL queries to return entities or primitive types l Queries as magic strings l Can call stored procedures and pass parameters to them 30

31 SQL query examples 31

32 Transactions l DbContext to some extent defines transactions l Changes are not sent to database until committed with SaveChanges l May want to encapsulate operations in true transactions l Use TransactionScope in.net l Needs to be supported by database provider l Local or distributed transactions l Transaction can include multiple contexts 32

33 Transactions example Save changes in two contexts Object added to second context is invalid, will throw exception on SaveChanges Changes already saved within transaction through first context will also roll back 33

34 ObjectContext l DbContext provides a useful set of functionality, but some capabilities of ObjectContext are not provided l Need to drop down to underlying ObjectContext in some (rare) circumstances l (can do this with DbContext better example is to generate EDMX..) 34

35 References 1. bb aspx /08/02/query-objects-with-therepository-pattern/ 4. predicatebuilder.aspx 35