/// <summary>
/// 执行select操作
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="source"></param>
/// <param name="selector"></param>
/// <returns></returns>
public static LinqDLR2Sql <TResult> Select <TSource, TResult>(this LinqDLR2Sql <TSource> source, Func <TSource, TResult> selector)
{
var dt = DateTime.Now;
var v = selector.Invoke(source.Item);
var rtn = LinqDLR2Sql <TResult> .New <LinqDLR2Sql <TResult> >(v, source.Table, source.AliasName, source.LinkedDBType);
rtn.DoSelect <TSource>(source);
return(rtn);
}
public static LinqDLR2Sql <TResult> Join <TOuter, TInner, TKey, TResult>(this LinqDLR2Sql <TOuter> outer, LinqDLR2Sql <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector)
{
var v1 = outerKeySelector.Invoke(outer.Item);
var v2 = innerKeySelector.Invoke(inner.Item);
var re = resultSelector.Invoke(outer.Item, inner.Item);
var rtn = LinqDLR2Sql <TResult> .New <LinqDLR2Sql <TResult> >(re, "", "", outer.LinkedDBType);
rtn.DoJoin <TOuter, TInner>(outer, inner, v1, v2);
return(rtn);
}
/// <summary>
/// 做多重from筛选结果集
/// lamda推理逻辑：
/// 1.lamda根据泛型来进行推算，因此SelectMany的算法只适用于泛型
/// 2.因为涉及到多重推算，即多个from，所以lamda会根据返回结果推算运用到参加下一次推算的TSource结构，
/// 即从上自下进行from推算，第一个和第二个from根据resultSelector算出了TResult的结构，返回值必须返回一个带TResult的对象，不然后面的推算就会失败，
/// 上面算出来的结果会参与到第三个的from运算，lamda根据上次返回的TResult作为这次运算中TSource的结构定义来参与本次运算。
/// 后面依次类推。
/// 所以resultSelector返回值TResult必须包含在返回值的结构定义中，不然递归推算就断裂
/// 所以selectmany只能用泛型来做定义
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TCollector"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="source"></param>
/// <param name="from"></param>
/// <param name="resultSelector"></param>
/// <returns></returns>
public static LinqDLR2Sql <TResult> SelectMany <TSource, TCollector, TResult>(this LinqDLR2Sql <TSource> source, Func <TSource, LinqDLR2Sql <TCollector> > from, Func <TSource, TCollector, TResult> resultSelector)
{
//第一轮from
var fromtable = from.Invoke(source.Item);
var rtn = LinqDLR2Sql <TResult> .New <LinqDLR2Sql <TResult> >(resultSelector.Invoke(source.Item, fromtable.Item), "", "", fromtable.LinkedDBType);
rtn.DoSelectMany <TSource>(source);
rtn.DoSelectMany <TCollector>(fromtable);
return(rtn);
}
/// <summary>
/// 执行select操作
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="source"></param>
/// <param name="selector"></param>
/// <returns></returns>
public static LinqDLR2Sql <TResult> Select <TSource, TResult>(this LinqDLR2Sql <TSource> source, Func <TSource, TResult> selector)
{
var dt = DateTime.Now;
var v = selector.Invoke(source.Item);
var rtn = LinqDLR2Sql <TResult> .New <LinqDLR2Sql <TResult> >(v, source.Table, source.AliasName, source.SQLGenerator);
using (source)
{
rtn.SQLGenerator.DoSelect(rtn);
//SQLGenerator共用一个
source.SQLGenerator = null;
}
return(rtn);
}
public static LinqDLR2Sql <TResult> Join <TOuter, TInner, TKey, TResult>(this LinqDLR2Sql <TOuter> outer, LinqDLR2Sql <TInner> inner, Func <TOuter, TKey> outerKeySelector, Func <TInner, TKey> innerKeySelector, Func <TOuter, TInner, TResult> resultSelector)
{
var v1 = outerKeySelector.Invoke(outer.Item);
var v2 = innerKeySelector.Invoke(inner.Item);
var re = resultSelector.Invoke(outer.Item, inner.Item);
var rtn = LinqDLR2Sql <TResult> .New <LinqDLR2Sql <TResult> >(re, "", "", outer.SQLGenerator);
using (outer)
{
using (inner)
{
rtn.SQLGenerator.DoJoin(rtn, outer, inner, v1, v2);
//SQLGenerator共用一个
outer.SQLGenerator = null;
}
}
return(rtn);
}
/// <summary>
/// 做多重from筛选结果集
/// lamda推理逻辑：
/// 1.lamda根据泛型来进行推算，因此SelectMany的算法只适用于泛型
/// 2.因为涉及到多重推算，即多个from，所以lamda会根据返回结果推算运用到参加下一次推算的TSource结构，
/// 即从上自下进行from推算，第一个和第二个from根据resultSelector算出了TResult的结构，返回值必须返回一个带TResult的对象，不然后面的推算就会失败，
/// 上面算出来的结果会参与到第三个的from运算，lamda根据上次返回的TResult作为这次运算中TSource的结构定义来参与本次运算。
/// 后面依次类推。
/// 所以resultSelector返回值TResult必须包含在返回值的结构定义中，不然递归推算就断裂
/// 所以selectmany只能用泛型来做定义
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TCollector"></typeparam>
/// <typeparam name="TResult"></typeparam>
/// <param name="source"></param>
/// <param name="from"></param>
/// <param name="resultSelector"></param>
/// <returns></returns>
public static LinqDLR2Sql <TResult> SelectMany <TSource, TCollector, TResult>(this LinqDLR2Sql <TSource> source, Func <TSource, LinqDLR2Sql <TCollector> > from, Func <TSource, TCollector, TResult> resultSelector)
{
//第一轮from
var fromtable = from.Invoke(source.Item);
var rtn = LinqDLR2Sql <TResult> .New <LinqDLR2Sql <TResult> >(resultSelector.Invoke(source.Item, fromtable.Item), "", "", source.SQLGenerator);
using (source)
{
rtn.SQLGenerator.DoSelectMany(rtn, source);
//source的SQLGenerator被rtn共用
source.SQLGenerator = null;
}
using (fromtable)
{
rtn.SQLGenerator.DoSelectMany(rtn, fromtable);
}
return(rtn);
}
/// <summary>
/// 执行GroupBy操作,join表操作
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <typeparam name="TKey"></typeparam>
/// <typeparam name="TElement"></typeparam>
/// <param name="source"></param>
/// <param name="keySelector"></param>
/// <param name="elementSelector"></param>
/// <returns></returns>
public static LinqDLR2Sql <TElement> GroupBy <TSource, TKey, TElement>(this LinqDLR2Sql <TSource> source, Func <TSource, TKey> keySelector, Func <TSource, TElement> elementSelector)
{
/*对应的group by语句为
* group <TElement> by <TKey> into g
* 其中linq会根据return类型来推断g的结构
*/
var tmp = keySelector(source.Item);
//element
var tmp2 = elementSelector(source.Item);
using (source)
{
var rtn = LinqDLR2Sql <TElement> .New <LinqDLR2Sql <TElement> >(tmp2, source.Table, source.AliasName, source.SQLGenerator);
rtn.SQLGenerator.DoGroupBy(rtn, source, tmp);
//与source共用一个SQLGenerator
source.SQLGenerator = null;
return(rtn);
}
}
