相关文章内容索引：
［概念回顾］
我们在前一篇《ORM查询语言（OQL）简介--概念篇》中了解到，SQL跟ORM的关系，ORM会自动生成SQL语句并执行，但普通的ORM框架却不能灵活的生成需要的SQL语句，我们需要一种具有SQL灵活性的的但却能够面向对象的ORM查询语言（ORM Query Language）--OQL。Hibernate的HQL，MS Entity Framework的ESQL都是这样的一种语言，虽然HQL和ESQL解决了它们框架OO使用方式的不灵活，但却是字符串类型的查询语句，使用起来并不便利，好在EF一般都是使用Linq表达式来编写查询，但Linq方式跟SQL在语法上还是有很大的差异，特别是Linq的左、右连接查询，跟SQL差异很大。而PDF.NET框架的OQL，应该是三者跟SQL最为接近的一种查询语言。
总结起来，OQL有下面3个显著特点：
- 抽象的ＳＱＬ，屏蔽了具体数据库的差异，因此支持所有数据库；
- 对象化的“ＳＱＬ”，写OQL代码能够获得IDE的智能提示；
- 没有使用.NET的特性，比如泛型、反射、表达式树等东西，因此理论上OQL可以跨语言平台，比如移植到Java，C++，VB等。
PS:PDF.NET并不仅仅是一个ORM框架，它是一个多模式的开发框架，详见官网说明 http://www.pwmis.com/sqlmap
在前一篇中，我们使用了巴科斯范式（NBF）来描述OQL的语法，但不少朋友不太清楚具体该如何使用，本篇我们将使用实例来说明如何使用OQL。
[OQL原理]
.表达式的链式调用
OQL的设计完全基于面向对象的实体查询，OQL的使用采用对象表达式的方式，内部实现原理是一系列的“链式方法调用”。为了完整实现SQL的查询过程，需要为这些表达式方法进行分级：
- 根表达式（OQL）、
- 一级表达式（OQL1）、
- 二级表达式（OQL2、OQLCompare等）
每一级表达式会生成是和使用下一级表达式，比如OQL调用返回OQL1对象的方法，而OQL1对象又调用返回OQL2级对象的方法。
将表达式按照层级划分，保证了编写OQL语句的正确性，可以避免因SQL语法不熟悉的开发人员写出错误的SQL语句，另外由于面向对象的方式，还可以避免写错数据库的表和字段名，在程序的编译阶段就发现错误而不是等到程序运行时。
.属性的实例调用
使用ORM，涉及到一个绕不开的问题，就是如何获取表的字段，EF是通过Linq来进行翻译的，本质上不是直接调用得到字段名称，在调用的时候，都是通过泛型方式的Lambda表达式来做的，这样是比较方便，但PDF.NET采用了另外一种方式，就是实体类的属性调用方式，来得到字段的名称。
为什么要使用这种方式？我主要是基于以下几点问题考虑：
- 平台无关性：对象的属性调用只要是面向对象的语言都可以，比如C++，VB，.NET,Java....,OQL是可以进行其它平台移植的
- .NET框架低版本支持：框架仅需.NET 2.0 支持，如果引入Linq方式，那么意味着框架需要.net 3.5及以上版本支持
- 简化条件调用：在Where方法中直接调用实体类的属性，不仅得到了调用的字段名，还得到了要查询的字段值
[示例说明]
在PDF.NET的开源项目（http://pwmis.codeplex.com ）中，有一个示例项目：《超市管理系统》，该项目演示了OQL的基本使用。下面我们说明下如何具体使用这些功能，详细的实例代码大家可以去这个开源网站下载。
一、OQL 数据查询：
[示例1]--查询所有收银员：
收银员只是雇员的一种类型，因此我们从雇员表中查找工作岗位类型名称是收银员的雇员信息，并且以姓名排序：
Employee emp = new Employee(); emp.JobName = "收银员"; OQL q = OQL.From(emp) .Select(emp.WorkNumber,emp.EmployeeName) .Where(emp.JobName) .OrderBy(emp.EmployeeName, "asc") .END;
下面，我们对这段代码中的OQL方法进行详细的说明。
1.1、OQL根表达式
--返回OQL对象的方法或者属性调用
1.1.1，From 方法：
是一个静态方法，它以一个实体类对象为参数，返回值是一个OQL实例对象：
/// <summary> /// 静态实体对象表达式 /// </summary> /// <param name="e">实体对象实例</param> /// <returns>实体对象查询表达式</returns> public static OQL From(EntityBase e) { //... ... }
1.1.2，实例方法
除了使用From静态方法构造OQL的实例，也可以采取直接调用构造函数的方式，比如本例这样使用：
OQL q=new OQL(emp); q.Select(emp.WorkNumber,emp.EmployeeName) .Where(emp.JobName) .OrderBy(emp.EmployeeName, "asc");
1.1.3，End 属性
从前面可以知道，可以静态From方式和直接调用构造函数方式的得到OQL，前者结尾有一个 .End 属性调用，因为 OrderBy 方法返回的对象是OQL1，而不是OQL，所以需要调用End 属性，返回本次操作OQL的当前对象实例，下面的方法实现能够说明这个原理：
public OQL END { get { return this.CurrOQL; } }
当我们需要在一行代码内进行查询的时候，调用End属性非常方便，它可以直接把当前OQL对象返回给EntityQuery查询对象，比如一行代码查询用户列表：
var userList=OQL.From<User>().Select().End.ToList<User>();
注意： 这里用上了PDF.NET框架的OQL扩展，需要项目引用PWMIS.Core.Extensions.dll 以及在你的代码文件上引入名字空间：
using PWMIS.Core.Extensions;
详细例子请参看《不使用反射，“一行代码”实现Web、WinForm窗体表单数据的填充、收集、清除，和到数据库的CRUD》
1.2、OQL一级表达式
--返回OQL1对象的方法或者属性调用，该级别的方法由OQL根级表达式生成并使用。
1.2.1，Select 方法：
选取查询需要的实体类属性，下面是方法定义：
/// <summary> /// 选取实体对象的属性 /// </summary> /// <param name="fields">属性字段列表</param> /// <returns>实体对象查询基本表达式</returns> public OQL1 Select(params object[] fields) { //... ... }
比如这里选取了雇员实体类的 工号（WorkNumber）、雇员名称（EmployeeName）两个属性，实际上，雇员表有多个字段：
"工号", "姓名", "性别","出生日期","入职时间","职务名称"
但我们这里不需要这么多，只需要上面2个即可。
“字段名按需选取”应该是一个成熟的ORM框架具备的功能之一，如果需要选取全部字段，也就是SQL的*：
Select * From table
那么OQL1的Select方法不传入参数即可：
OQL q=new OQL(emp); q.Select();
选取多个实体属性（多表字段）：
上面的例子是选取单个实体（表）的方式，选取多个实体类的属性是类似的，Select方法的参数使用不同的实体类的属性即可：
OQL q=OQL.From(entity1)
.InnerJoin(entity2).On(entity1.PK,entity2.FK)
.Select(entity1.Field1,entity1.Field2,entity2.Field1,entity2.Field2....)
.End;
正是因为PDF.NET的OQL的Select等方法，都是使用“实体类.属性”调用的方式，使得操作多个实体类方便快捷，试想如果采用泛型，这个Select方法应该有多少个重载呢？
1.2.2，Where方法：
设置OQL的查询条件。
Where方法有几种重载，每种方法各有特点，先看看方法声明：
1.2.2.1，直接使用多个条件属性作为并列的Where查询条件
适用于直接利用属性值作为字段“=”值操作的“And”条件方式：
/// <summary> /// 获取并列查询条件，如 Where(u.Uid,u.Name); /// </summary> /// <param name="expression">实体属性列表</param> /// <returns>基本表达式</returns> public OQL1 Where(params object[] expression)
比如本文的例子，查找制定工作职位名的雇员信息：
q.Select(emp.WorkNumber,emp.EmployeeName) .Where(emp.JobName) .OrderBy(emp.EmployeeName, "asc");
1.2.2.2，使用OQL2 条件对象作为参数
可以按照顺序进行条件的Not，And，Or操作，方法定义：
/// <summary> /// 获取复杂查询条件 /// </summary> /// <param name="c">多条件表达式</param> /// <returns>基本表达式</returns> public OQL1 Where(OQL2 c)
OQL对象实例中已经有一个OQL2对象的属性Condition，可以直接使用，下面是例子：
[示例2]--获取所有的可售商品总数
/// <summary> /// 获取所有的可售商品总数 /// </summary> /// <returns></returns> public int GetGoodsStockCount() { GoodsStock stock = new GoodsStock(); OQL q = new OQL(stock); q.Select() .Count(stock.Stocks, "库存数量") .Where(q.Condition.AND(stock.Stocks, ">", 0)); stock = EntityQuery<GoodsStock>.QueryObject(q); return stock.Stocks; }
1.2.2.3，使用OQLCompare对象作为参数
OQLCompare 对象是一个组合对象，也就是N个OQLComapre可以按照各种条件组合成一个OQLCompare对象，从而构造超级复杂的Where查询条件，支持带括号“（）”的条件组合，后面会有实例展示。
/// <summary> /// 获取复杂查询条件(具有逻辑优先级的复杂比较条件） /// </summary> /// <param name="compare">实体对象比较类</param> /// <returns>基本表达式</returns> public OQL1 Where(OQLCompare compare)
下面是一个使用OQLComapre对象处理非常复杂的条件查询例子，
生成OQL查询
/// <summary> /// 生成查询数据的OQL对象 /// </summary> /// <param name="qcItem"></param> /// <returns></returns> private OQL getOQLSelect(QueryConditionModel qcItem) { TsCarSource cs = initCarSourceFromQueryCondition(qcItem); PublishInfo ap = new PublishInfo(); // StartTime,EndTime 属于复杂查询 BidRecord br = new BidRecord(); TstOrder tst = new TstOrder(); OQLCompare cmpResult = getOQLCompare(qcItem, cs, ap, tst); OQL q = OQL.From(cs) .InnerJoin(ap).On(cs.CarSourceID, ap.CarSourceId) .LeftJoin(tst).On(cs.CarSourceID, tst.CarSourceID) .Select( cs.CarSourceID, cs.ProducerId, cs.BrandId, cs.CityAreaId, cs.CarSourceOwner, cs.CityId, cs.CarIdentityNumber, cs.TvaID, cs.CarSourceOwner, cs.LicenseNumber, cs.CarUseType, cs.PurchasePrice, ap.PublishId, ap.StartTime, ap.EndTime, ap.ReservationPrice, ap.StartPrice,ap.HighestBidprice,tst.BargainPrice,ap.Status,ap.BidCount,ap.BidListCount,ap.PriceEndTime,ap.StopTime,ap.PriceStopTime, cs.MasterBrandId,cs.CarTypeId,cs.CarBodyColor,cs.Mileage ) .Where(cmpResult) .OrderBy(ap.StartTime, "desc") //PublishInfo.StartTime desc .END; return q; } /// <summary> /// 生成条件比较对象 /// </summary> /// <param name="qcItem"></param> /// <param name="cs"></param> /// <param name="ap"></param> /// <param name="br"></param> /// <returns></returns> private OQLCompare getOQLCompare(QueryConditionModel qcItem, TsCarSource cs, PublishInfo ap, TstOrder tst) { OQLCompare cmp = new OQLCompare(cs, ap, tst); OQLCompare cmpResult = null; if (qcItem.AccountType.Value == 1) { cs.TvaID = qcItem.TvaId.Value; cmpResult = cmp.Comparer(cs.TvaID); } else { string tvaids = GetTvaidList(qcItem.TvaId.Value);//in cmpResult = cmp.Comparer(cs.TvaID, OQLCompare.CompareType.IN, tvaids);//in } if (qcItem.TabIndex == 1)//拍卖中 { ap.Status = 1; cmpResult = cmpResult&cmp.Comparer(ap.Status); } else //PriceStatus大于1，为拍卖结束的 { cmpResult = cmpResult&cmp.Comparer(ap.Status, OQLCompare.CompareType.Greater, 1); } if (qcItem.QueryType == 0) { //默认查询条件 } else if (qcItem.QueryType == 1) { //按照Vin码或者号牌进行查询 cmpResult = cmpResult & ( cmp.Comparer(cs.LicenseNumber, OQLCompare.CompareType.Like,"%"+ qcItem.VinCodeOrPlateNumber+"%") | cmp.Comparer(cs.CarIdentityNumber, OQLCompare.CompareType.Like, "%" + qcItem.VinCodeOrPlateNumber + "%") ); } else { //其它复杂查询条件 //处理区域条件 if (qcItem.CityId.HasValue && qcItem.CityId.Value > 0) { cmpResult = cmpResult & cmp.Comparer(cs.CityId, "=", qcItem.CityId.Value); } else if (qcItem.ProvinceId.HasValue && qcItem.ProvinceId.Value > 0) { cmpResult = cmpResult & cmp.Comparer(cs.ProvinceId, "=", qcItem.ProvinceId.Value); } else if (qcItem.BigAreaId.HasValue && qcItem.BigAreaId.Value > 0) { var provinces = new CommonDL().GetProvincesByBigAreaID(qcItem.BigAreaId.Value); if (provinces.Count > 0) { var provinceids = string.Join(",", provinces.Select(o => o.ProvinceId)); cmpResult = cmpResult & cmp.Comparer(cs.ProvinceId, OQLCompare.CompareType.IN, provinceids); } } //end if (!string.IsNullOrEmpty(qcItem.State) && qcItem.State!="0"&&qcItem.TabIndex.Value==2) cmpResult = cmpResult & cmp.Comparer(ap.Status, "=", Convert.ToByte( qcItem.State)); //if (cs.CityAreaId > 0) // cmpResult = cmpResult & cmp.Comparer(cs.CityAreaId); if(qcItem.BrandId.HasValue&&qcItem.BrandId.Value>0) cmpResult = cmpResult & cmp.Comparer(cs.MasterBrandId, "=", qcItem.BrandId.Value); if (qcItem.SerialId.HasValue&&qcItem.SerialId.Value>0) cmpResult = cmpResult & cmp.Comparer(cs.BrandId,"=",qcItem.SerialId.Value); if (qcItem.StartTime.HasValue) cmpResult = cmpResult & cmp.Comparer(ap.PriceStopTime, OQLCompare.CompareType.GreaterThanOrEqual, qcItem.StartTime.Value); if(qcItem.EndTime.HasValue) cmpResult = cmpResult & cmp.Comparer(ap.PriceStopTime, OQLCompare.CompareType.LessThanOrEqual, qcItem.EndTime.Value.AddDays(1)); if (!string.IsNullOrEmpty(qcItem.EndTimePoint)) { string[] items= qcItem.EndTimePoint.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries); //多个时间点的OR条件组合 List<OQLCompare> OrCmp1 = new List<OQLCompare>(); foreach (string item in items) { int hour = int.Parse(item); if (hour != 0) { //今日3个时段结束的 OQLCompare cmpTemp = cmp.Comparer(ap.PriceEndTime, "=", hour, "DATEPART(hh,{0})"); OrCmp1.Add(cmpTemp); } else { //明日结束的 OQLCompare cmpOther= cmp.Comparer(ap.PriceEndTime, ">=", DateTime.Now.Date.AddDays(1)); OrCmp1.Add(cmpOther); } } cmpResult = cmpResult & cmp.Comparer(OrCmp1, OQLCompare.CompareLogic.OR); } } return cmpResult; }
PS：由于查询比较复杂，请先看了下面有关OQL关联实体查询之后再看本例。这个示例中的OQLCompare对象使用方式已经过时，请看本文【2.1.1，更新指定范围的数据】黄色标记的部分，现在OQLCompare对象不支持从实体类实例化，而是必须从OQL对象实例化。。
执行查询会生成如下复杂的SQL语句：
SELECT cs.CarSourceID, ap.PublishId, cs.ProducerId,cs.BrandId,cs.CityAreaId, cs.ProducerId,cs.CityId,cs.CarIdentityNumber,cs.TvaID,cs.CarSourceOwner, cs.LicenseNumber,cs.CarUseType,cs.CarStatus, ap.StartTime,ap.EndTime, ap.AnticipantPrice,ap.StartPrice, br.CurrPrice FROM dbo.TranstarCarSource AS cs INNER JOIN dbo.PublishInfo AS ap ON cs.CarSourceID=ap.CarSourceId INNER JOIN dbo.BidRecord AS br ON ap.PublishId=br.PublishId WHERE cs.CarStatus=1
And （/* 这里是动态构造的查询条件*/ ）
1.2.2.4，使用QueryParameter 数组作为并列的查询参数
适合于专门的表单查询界面，比如指定日期字段要大于某天且要小于某天。将表单查询页面的控件的值收集到QueryParameter 对象即可完成此查询。
/// <summary> /// 根据传入的查询参数数组，对字段名执行不区分大小写的比较，生成查询条件。 /// </summary> /// <param name="queryParas">查询参数数组</param> /// <returns>条件表达式</returns> public OQL1 Where(QueryParameter[] queryParas)
1.2.3，OrderBy方法：
设置OQL的排序方式，分为2种方式：
1.2.3.1，直接指定排序属性和方式：
/// <summary> /// 设定排序条件 /// </summary> /// <param name="field">实体对象属性</param> /// <param name="orderType">排序类型 ASC，DESC</param> /// <returns></returns> public OQL1 OrderBy(object field, string orderType)
该方法很简单，就是传入一个要排序的实体类属性和排序的方式（降序、增序），如本例：
OQL q=new OQL(emp); q.Select(emp.WorkNumber,emp.EmployeeName) .Where(emp.JobName) .OrderBy(emp.EmployeeName, "asc");
1.2.3.2，使用OQLOrder 排序对象：
public OQL1 OrderBy(OQLOrder order) { //... ... }
例如下面的使用方式，对“用户属性视图”进行总成绩查询且以UID方式排序：
[示例3]--OQLOrder对象排序
UserPropertyView up = new UserPropertyView(); OQL q = new OQL(up); OQLOrder order = new OQLOrder(up); q.Select() .Where(q.Condition.AND(up.PropertyName, "=", "总成绩").AND(up.PropertyValue,">",1000)) .OrderBy(order.Asc(up.UID));
二、数据修改
OQL提供了在表达式级别的数据修改、删除数据写入操作，数据的插入不需要使用OQL，直接调用EntityQuery<T> 对象的Inert方法即可。
2.1，更新数据
/// <summary> /// 更新实体类的某些属性值，如果未指定条件，则使用主键值为条件。 /// </summary> /// <param name="fields">实体属性列表</param> /// <returns>条件表达式</returns> public OQL1 Update(params object[] fields)
2.1.1，更新指定范围的数据
由于方法返回的是OQL1对象，意味着OQL的更新表达式可以后续使用Where方法来限定要更新的范围，
例如下面的例子，修改雇员“张三”的工号为“123456”：
Employee emp = new Employee(); emp.WorkNumber = "123456"; emp.EmployeeName="张三"; OQL q=OQL.From(emp) .Update(emp.WorkNumber) .Where(emp.EmployeeName) .End; EntityQuery<Employee>.Instance.ExecuteOql(q);
上面的例子只会更新一条记录，指定相应的Where参数，OQL还可以进行复杂条件的更新或者更新多条记录。
如果需要更复杂的更新条件，也可以在Where中使用OQLCompare对象，但由于当前版本的OQL处理机制问题，规定在Update操作的是后，OQL跟OQLCompare 不用用同样一个实体类实例，如下面的写法是错误的：
LT_Users userCmp = new LT_Users();
LT_Users userQ = new LT_Users();
//OQLCompare cmp = new OQLCompare(userCmp);//过时
OQL q = new OQL(userQ);
OQLCompare cmp = new OQLCompare(q);
OQLCompare cmpResult = cmp.Comparer(userCmp.ID, "in", "1,2,3")
& cmp.Comparer(userCmp.LastLoginIP, "=", "127.0.0.1");
q.Update(userQ.Authority).Where(cmpResult);正确的方式应该这样：
LT_Users user = new LT_Users();
//OQLCompare cmp = new OQLCompare(userCmp);//过时
OQL q = new OQL(user);
OQLCompare cmp = new OQLCompare(q);
OQLCompare cmpResult = cmp.Comparer(user.ID, "in", "1,2,3")
& cmp.Comparer(user.LastLoginIP, "=", "127.0.0.1");
q.Update(user.Authority).Where(cmpResult);
PS：更新单个实体对象，可以直接使用 EntityQuery而不需要使用OQL，但必须指定实体对象的主键值，例如上面的例子可以修改成：
Employee emp = new Employee(); emp.WorkNumber = "123456"; emp.UserID=100;//主键 EntityQuery<Employee>.Instance.Update(q);
2.1.2，UpdateSelf 字段自更新
用于数字型字段的值加、减一个新值得情况，比如更新会员的积分，购买物品后将会员的原有积分加上本次获得的积分。
[示例4]--更新会员积分
AdoHelper db = MyDB.GetDBHelper(); //... 其它代码略 SuperMarketDAL.Entitys.CustomerContactInfo ccInfo = new CustomerContactInfo(); ccInfo.CustomerID = customer.CustomerID; ccInfo.Integral = integral; OQL qc = OQL.From(ccInfo) .UpdateSelf('+', ccInfo.Integral ) .Where(ccInfo.CustomerID ) .END; EntityQuery<SuperMarketDAL.Entitys.GoodsStock>.ExecuteOql(qc, db);
采用这种方式，就不必事先进行一个查询将积分先查询出来，修改后再更新到数据库，节省了一次数据查询过程。
2.2，删除数据
/// <summary> /// 删除实体类，如果未指定条件，则使用主键值为条件。 /// </summary> /// <returns>条件表达式</returns> public OQL1 Delete()
由于方法返回的是OQL1对象，意味着OQL的删除表达式可以后续使用Where方法来限定要删除的范围，
例如下面的例子，删除雇员“张三”的记录：
Employee emp = new Employee(); emp.EmployeeName="张三"; OQL q=OQL.From(emp) .Delete() .Where(emp.EmployeeName) .End; EntityQuery<Employee>.Instance.ExecuteOql(q);
PS：删除单个实体对象，可以直接使用 EntityQuery而不需要使用OQL，但必须指定实体对象的主键值，例如上面的例子可以修改成：
Employee emp = new Employee(); emp.UserID=100;//主键 EntityQuery<Employee>.Instance.Delete(q);
三、统计、聚合运算
在SQL中，统计使用Count 谓词，而其它的聚合运算还有 求平均AVG，求和SUM，求最大MAX，求最小MIN，这些OQL都支持，且用法一样，下面看一个统计记录数的例子：
[示例5]--获取联系人信息记录数量：
public int GetContactInfoCount() { CustomerContactInfo info = new CustomerContactInfo(); OQL q = OQL.From(info) .Select() .Count(info.CustomerID, "tempField")
.END; CustomerContactInfo infoCount = EntityQuery<CustomerContactInfo>.QueryObject(q); return Convert.ToInt32(infoCount.PropertyList("tempField"));
}
这里按照客户号进行统计，将统计结果放到SQL的列别名“tempField”中去，最后可以通过实体类的PropertyList 方法取得该值。
注："tempField" 并不是实体类CustomerContactInfo 固有的字段，只是SQL查询出来的一个别名字段而已，但实体类仍然可以访问它，这就体现了PDF.NET的实体类其实是一个“数据容器”的概念。
如果不使用别名,那么随意选取一个int ,long 类型的实体类属性，存放结果即可，比如本例仍然使用 CustomerID ：
public int GetContactInfoCount() { CustomerContactInfo info = new CustomerContactInfo(); OQL q = OQL.From(info) .Select() .Count(info.CustomerID, "") .END; CustomerContactInfo infoCount = EntityQuery<CustomerContactInfo>.QueryObject(q); return infoCount.CustomerID; }
这样，查询记录总数，使用 infoCount.CustomerID 就好了，这个例子也说明了，PDF.NET SOD 实体类,就是数据的容器。
PS：类似的，将OQL的Count 方法替换成其它聚合方法，可以完成相应的SQL计算功能，OQL代码都是类似的。
如果聚合运算同时合并分组计算，聚合函数使用的时候最好指定别名，方便选取结果，如下示例：
Table_User user = new Table_User(); OQL q = OQL.From(user) .Select().Avg(user.Height,"AvgHeight") .GroupBy(user.Sex) .END; EntityContainer ec = new EntityContainer(q); var result= ec.MapToList(() => new { //获取聚合函数的值，用下面一行代码的方式 AvgHeight= ec.GetItemValue<double>("AvgHeight"), Sex = user.Sex ?"男":"女" });
如上按照性别分组查询男女的平均身高，平均身高字段指定了别名“AvgHeight”，那么在分组查询后，用延迟指定查询字段的方式（在MapToList里面指定，参见5.3，延迟Select指定实体类属性 ），在方法内使用 ec.GetItemValue<double>("AvgHeight") 方法根据平均身高字段的别名获取查询的字段值。
注意：在MapToList方法中使用 ec.GetItemValue 的方式，需要SOD框架的PWMIS.Core.dll 文件版本是5.6.2.0607 以上。
执行上面的查询，会生成下面的SQL语句：
SELECT [Sex] ,AVG( [Height]) AS AvgHeight FROM [Table_User] GROUP BY [Sex]
四、OQL分页
SqlServer 2012之前并没有直接提供分页的关键词，需要用户自己编写分页SQL语句，比较麻烦，其它数据库比如MySQL,SQLite等提供了分页关键词Limit，OQL借鉴了它的特点进行分页，下面是例子：
[示例6]--获取指定页的联系人信息
/// <summary> /// 获取指定页的联系人信息 /// </summary> /// <param name="pageSize">每页的记录数大小</param> /// <param name="pageNumber">页码</param> /// <param name="allCount">总记录数</param> /// <returns></returns> public List<CustomerContactInfo> GetContactInfoList(int pageSize, int pageNumber, int allCount) { CustomerContactInfo info = new CustomerContactInfo(); OQL q = new OQL(info); q.Select().OrderBy(info.CustomerName, "asc"); q.Limit(pageSize, pageNumber); q.PageWithAllRecordCount = allCount; return EntityQuery<CustomerContactInfo>.QueryList(q); }
注意：OQL分页的时候除了调用Limit方法指定页大小和页码之外，还必须告诉它记录总数量，否则可能分页不准确。
五、OQL多实体关联查询
在SQL中多表查询的时候，表的关联查询分为内联 Inner Join，左连接Left Join，右连接 Right Join，OQL通过对实体类进行关联查询实现SQL类似的操作，而且语法非常类似，如果用过Linq做表外联结操作的朋友就知道，Linq的方式跟SQL差异很大的，这里不多说，感兴趣的朋友请去查阅相关资料。
5.1，OQL实体连接方法定义：
/// <summary> /// 内连接查询 /// </summary> /// <param name="e">要连接的实体对象</param> /// <returns>连接对象</returns> public JoinEntity Join(EntityBase e) { return Join(e, "INNER JOIN"); } /// <summary> /// 内连接查询 /// </summary> /// <param name="e">要连接的实体对象</param> /// <returns>连接对象</returns> public JoinEntity InnerJoin(EntityBase e) { return Join(e, "INNER JOIN"); } /// <summary> /// 左连接查询 /// </summary> /// <param name="e">要连接的实体对象</param> /// <returns>连接对象</returns> public JoinEntity LeftJoin(EntityBase e) { return Join(e, "LEFT JOIN"); } /// <summary> /// 右连接查询 /// </summary> /// <param name="e">要连接的实体对象</param> /// <returns>连接对象</returns> public JoinEntity RightJoin(EntityBase e) { return Join(e, "RIGHT JOIN"); }
5.2，[示例7]获取商品销售单视图：
该查询需要将“商品销售单实体”GoodsSellNote、“雇员”Employee、“客户联系信息”CustomerContactInfo 三个实体类进行关联查询得到，其中销售员编号跟雇员工号关联，销售单和客户信息的客户编号关联，下面给出OQL多实体类连接的实例代码：
public IEnumerable<GoodsSellNoteVM> GetGoodsSellNote() { GoodsSellNote note = new GoodsSellNote(); Employee emp = new Employee(); CustomerContactInfo cst=new CustomerContactInfo (); OQL joinQ = OQL.From(note) .InnerJoin(emp).On(note.SalesmanID, emp.WorkNumber) .InnerJoin(cst).On(note.CustomerID, cst.CustomerID) .Select(note.NoteID, cst.CustomerName, note.ManchinesNumber, emp.EmployeeName, note.SalesType, note.SellDate) .OrderBy(note.NoteID, "desc") .END; PWMIS.DataProvider.Data.AdoHelper db = PWMIS.DataProvider.Adapter.MyDB.GetDBHelper(); EntityContainer ec = new EntityContainer(joinQ, db); ec.Execute(); //可以使用下面的方式获得各个成员元素列表 //var noteList = ec.Map<GoodsSellNote>().ToList(); //var empList = ec.Map<Employee>().ToList(); //var cstList = ec.Map<CustomerContactInfo>().ToList(); //直接使用下面的方式获得新的视图对象 var result = ec.Map<GoodsSellNoteVM>(e => { e.NoteID = ec.GetItemValue<int>(0); e.CustomerName = ec.GetItemValue<string>(1); e.ManchinesNumber = ec.GetItemValue<string>(2); e.EmployeeName = ec.GetItemValue<string>(3); e.SalesType = ec.GetItemValue<string>(4); e.SellDate = ec.GetItemValue<DateTime>(5); return e; } ); return result; }
上面的例子中，先在OQL表达式的Select方法指定要查询的实体属性，然后在EntityContainer的Map方法内采用 GetItemValue 方法获取要查询的结果，查询的时候GetItemValue 方法参数可以为Select方法指定的实体类属性的索引顺序，也可以是实体类属性对应的字段名。
5.3，延迟Select指定实体类属性
上面的例子我们发现在Select方法和Map方法内多次指定了字段/属性信息，代码量比较重复，因此在后续版本中，支持将Select方法的实体属性选择推迟到Map方法内，所以上面的例子可以改写成下面这样子：
/// <summary> /// 获取商品销售价格信息 /// </summary> /// <returns></returns> public IEnumerable<GoodsSaleInfoVM> GetGoodsSaleInfo() { GoodsBaseInfo bInfo = new GoodsBaseInfo(); GoodsStock stock = new GoodsStock(); /* * Select采用指定详细实体类属性的方式： OQL joinQ = OQL.From(bInfo) .Join(stock).On(bInfo.SerialNumber, stock.SerialNumber) .Select( bInfo.GoodsName, bInfo.Manufacturer, bInfo.SerialNumber, stock.GoodsPrice, stock.MakeOnDate, bInfo.CanUserMonth, stock.Stocks, stock.GoodsID) .OrderBy(bInfo.GoodsName, "asc") .END; */ //Select 方法不指定具体要选择的实体类属性，可以推迟到EntityContainer类的MapToList 方法上指定 OQL joinQ = OQL.From(bInfo) .Join(stock).On(bInfo.SerialNumber, stock.SerialNumber) .Select() .OrderBy(bInfo.SerialNumber , "asc").OrderBy(bInfo.GoodsName, "asc") .END; joinQ.Limit(3, 3); PWMIS.DataProvider.Data.AdoHelper db = PWMIS.DataProvider.Adapter.MyDB.GetDBHelper(); EntityContainer ec = new EntityContainer(joinQ, db); /* * 如果OQL的Select方法指定了详细的实体类属性，那么映射结果，可以采取下面的方式： var result = ec.Map<GoodsSaleInfoVM>(e => { e.GoodsName = ec.GetItemValue<string>(0); e.Manufacturer = ec.GetItemValue<string>(1); e.SerialNumber = ec.GetItemValue<string>(2); e.GoodsPrice = ec.GetItemValue<decimal>(3); e.MakeOnDate = ec.GetItemValue<DateTime>(4); e.CanUserMonth = ec.GetItemValue<int>(5); e.Stocks = ec.GetItemValue<int>(6); e.GoodsID = ec.GetItemValue<int>(7); return e; } ); */ var result = ec.MapToList<GoodsSaleInfoVM>(() => new GoodsSaleInfoVM() { GoodsName = bInfo.GoodsName, Manufacturer=bInfo.Manufacturer, SerialNumber=bInfo.SerialNumber, GoodsPrice=stock.GoodsPrice, MakeOnDate=stock.MakeOnDate, CanUserMonth=bInfo.CanUserMonth, Stocks=stock.Stocks, GoodsID=stock.GoodsID, ExpireDate = stock.MakeOnDate.AddMonths(bInfo.CanUserMonth) }); return result; }
5.4，映射匿名查询结果
如果是局部使用多实体类的查询结果，可以不用定义这个“ViewModel”，在 MapToList方法中，直接使用匿名类型，例如下面的例子：
OQL q=OQL.From(entity1) .Join(entity2).On(entity1.PK,entity2.FK) //.Select(entity1.Field1,entity2.Field2) //不再需要指定查询的属性
.Select() .End; EntityContainer ec=new EntityContainer(q); var list=ec.MapToList(()=> { return new { Property1=entity1.Field1, Property2=entity2.Field2 }; }); foreache(var item in list) { Console.WriteLine("Property1={0},Property2={1}",item.Property1,item.Property2); }
有关OQL进行多实体类关联查询的原理介绍的信息，请参考这篇文章《打造轻量级的实体类数据容器》
我们再来看看Linq的左、右连接，比较下哪个跟SQL最为接近：
左连结
var LeftJoin = from emp in ListOfEmployees join dept in ListOfDepartment on emp.DeptID equals dept.ID into JoinedEmpDept from dept in JoinedEmpDept.DefaultIfEmpty() select new { EmployeeName = emp.Name, DepartmentName = dept != null ? dept.Name : null };
右连接
var RightJoin = from dept in ListOfDepartment join employee in ListOfEmployees on dept.ID equals employee.DeptID into joinDeptEmp from employee in joinDeptEmp.DefaultIfEmpty() select new { EmployeeName = employee != null ? employee.Name : null, DepartmentName = dept.Name };
[后记]
PDF.NET框架的很多用户朋友都在QQ里面跟我说出一份框架的详细使用手册，但框架涵盖的内容面比较大，功能点很多，框架的每个方法背后都有实际的项目代码例子，换句话说框架完全是从各个实际的项目中总结、提炼出来的。身为“一线码农”，框架的每个方法使用都历历在目，但广大PDF.NET的用户朋友或许并不知道这些方法的原理是什么，怎么使用，各种使用方法有什么区别，这些问题成为了前来咨询我框架使用的每个框架用户的问题，而我在QQ里面往往不可能回答得很具体全面，所以也就有了概念篇之后的这篇实例篇。尽管写这篇文章花了我1个周末，但还是感觉还有很多没有说仔细的地方，只有大家遇到问题的时候我们一起来讨论总结了！
最后，再一次感谢广大支持PDF.NET开发框架的朋友们，感谢无私的捐助会员用户们，是你们的支持让我们能够不断进步！
--------------分解线-----------------------------------------
欢迎加入PDF.NET开源项目 开发技术团队，做最轻最快的数据框架！