/// <summary>
/// 总行数
/// </summary>
/// <param name="functionHandle">函数</param>
/// <param name="param">字段</param>
/// <returns></returns>
public static BQLAggregateFunction Count(BQLParamHandle param)
{
BQLAggregateFunction item = new BQLAggregateFunction(DBAggregateFunction.DoCount, param);
item.ValueDbType = DbType.Int32;
return(item);
}
/// <summary>
/// 直接查询数据库视图
/// </summary>
/// <param name="table">表</param>
/// <param name="lstScope">条件</param>
/// <param name="vParams">字段列表</param>
/// <param name="lstSort">排序类型</param>
/// <param name="objPage">分页对象</param>
/// <returns></returns>
public DataSet SelectTable(BQLOtherTableHandle table, ScopeList lstScope)
{
List <BQLParamHandle> lstParams = GetParam(table, lstScope);
List <BQLParamHandle> lstOrders = new List <BQLParamHandle>();
BQLParamHandle order = null;
foreach (Sort objSort in lstScope.OrderBy)
{
order = table[objSort.PropertyName];
if (objSort.SortType == SortType.ASC)
{
order = order.ASC;
}
else
{
order = order.DESC;
}
lstOrders.Add(order);
}
BQLCondition where = BQLCondition.TrueValue;
where = FillCondition(where, table, lstScope, null);
BQLQuery bql = BQL.Select(lstParams.ToArray()).From(table).Where(where).OrderBy(lstOrders.ToArray());
if (lstScope.HasPage)
{
using (BatchAction ba = _oper.StarBatchAction())
{
return(QueryDataSet(bql, null, lstScope.PageContent, lstScope.UseCache));
}
}
return(QueryDataSet(bql, null, lstScope.UseCache));
}
/// <summary>
/// 条件函数
/// </summary>
/// <param name="sourceHandle">发送源(字段)</param>
/// <param name="query">查询</param>
/// <param name="handle">关联处理函数</param>
public BQLConditionItem(BQLParamHandle sourceHandle, BQLQuery query, DelConditionHandle handle)
{
this._sourceHandle = sourceHandle;
this._handle = handle;
this._query = query;
this._valueDbType = DbType.Boolean;
}
///// <summary>
///// 查询范围
///// </summary>
///// <param name="star">开始条数</param>
///// <param name="totalRecord">显示条数</param>
///// <returns></returns>
//public KeyWordLimitItem Limit(uint star, uint totalRecord)
//{
// KeyWordLimitItem item = new KeyWordLimitItem(star, totalRecord, this);
// return item;
//}
internal override void Tran(KeyWordInfomation info)
{
info.IsWhere = true;
string ret = "";
SelectCondition con = info.Condition as SelectCondition;
for (int i = 0; i < paramhandles.Count; i++)
{
BQLParamHandle prm = paramhandles[i];
string prmStr=prm.DisplayValue(info);
ret +=prmStr ;
if (i < paramhandles.Count - 1)
{
ret += ",";
}
if (con != null)
{
info.Condition.PrimaryKey.Add(prmStr);
}
}
info.Condition.GroupBy.Append(ret);
info.IsWhere = false;
//return " group by " + ret;
}
/// <summary>
/// 平均值
/// </summary>
/// <param name="functionHandle">函数</param>
/// <param name="param">字段</param>
/// <returns></returns>
public static BQLAggregateFunction Avg(BQLParamHandle param)
{
BQLAggregateFunction item = new BQLAggregateFunction(DBAggregateFunction.DoAvg, param);
item.ValueDbType = DbType.Double;
return(item);
}
internal override void LoadInfo(KeyWordInfomation info)
{
for (int i = 0; i < parameters.Length; i++)
{
BQLParamHandle prmHandle = parameters[i];
BQLValueItem.DoFillInfo(prmHandle, info);
}
}
//IAggregateFunctions agf = DbAdapterLoader.Aggregate;
/// <summary>
/// 总计
/// </summary>
/// <param name="functionHandle">函数</param>
/// <param name="param">字段</param>
/// <returns></returns>
public static BQLAggregateFunction Sum(BQLParamHandle param)
{
BQLAggregateFunction item = new BQLAggregateFunction(DBAggregateFunction.DoSum, param);
item.ValueDbType = DbType.Double;
//item.ValueDataType = DefaultType.DoubleType;
return(item);
}
/// <summary>
/// 获取别名字段
/// </summary>
/// <param name="propertyName"></param>
/// <returns></returns>
public BQLParamHandle GetAliasParam(string propertyName)
{
BQLAliasParamHandle prm = null;
BQLParamHandle ret = null;
if (_dicParams.TryGetValue(propertyName, out prm))
{
ret = BQL.ToParam(prm.AliasName);
ret.ValueDbType = prm.ValueDbType;
}
return(ret);
}
/// <summary>
/// 获取属性名
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
private string GetKey(BQLParamHandle parameter)
{
BQLEntityParamHandle ehandle = parameter as BQLEntityParamHandle;
if (!CommonMethods.IsNull(ehandle))
{
return(ehandle.PInfo.PropertyName);
}
BQLOtherParamHandle ohandle = parameter as BQLOtherParamHandle;
if (!CommonMethods.IsNull(ohandle))
{
return(ohandle.ParamName);
}
return(parameter.DisplayValue(BQLValueItem.GetKeyInfo()));
}
/// <summary>
/// 获取排序列表
/// </summary>
/// <param name="lstScort"></param>
/// <param name="table"></param>
/// <param name="entityType"></param>
/// <returns></returns>
internal static BQLParamHandle[] GetSort(SortList lstScort, BQLTableHandle table, EntityInfoHandle entityInfo)
{
List <BQLParamHandle> lstHandles = new List <BQLParamHandle>();
if (lstScort == null)
{
lstHandles.ToArray();
}
for (int i = 0; i < lstScort.Count; i++)
{
Sort objSort = lstScort[i];
BQLParamHandle handle = null;
if (!CommonMethods.IsNull(objSort.OrderHandle))
{
handle = objSort.OrderHandle;
}
else if (entityInfo != null)
{
//EntityPropertyInfo info = entityInfo.PropertyInfo[objSort.PropertyName];
if (objSort.SortType == SortType.ASC)
{
handle = table[objSort.PropertyName].ASC;
}
else
{
handle = table[objSort.PropertyName].DESC;
}
}
else
{
if (objSort.SortType == SortType.ASC)
{
handle = table[objSort.PropertyName].ASC;
}
else
{
handle = table[objSort.PropertyName].DESC;
}
}
lstHandles.Add(handle);
}
return(lstHandles.ToArray());
}
internal override void Tran(KeyWordInfomation info)
{
info.IsWhere = true;
StringBuilder condition = new StringBuilder();
for (int i = 0; i < parameters.Length; i++)
{
BQLParamHandle prmHandle = parameters[i];
condition.Append(prmHandle.DisplayValue(info));
if (i < parameters.Length - 1)
{
condition.Append(',');
}
}
info.Condition.Orders.Append(condition.ToString());
//return " order by " + condition.ToString();
info.IsWhere = false;
}
/// <summary>
/// 添加一个Update设置
/// </summary>
/// <param name="parameter">字段</param>
/// <param name="valueItem">值</param>
public void Add(BQLParamHandle parameter, BQLValueItem valueItem)
{
string key = GetKey(parameter);
this[key] = valueItem;
}
/// <summary>
/// 添加一个set项
/// </summary>
/// <param name="parameter">字段</param>
/// <param name="valueItem">值</param>
/// <returns></returns>
public KeyWordUpdateSetItem _(BQLParamHandle parameter, BQLValueItem valueItem)
{
lstItems.Add(parameter, valueItem);
return(this);
}
/// <summary>
/// Set关键字项
/// </summary>
/// <param name="parameter">要更新的字段</param>
/// <param name="valueItem">值</param>
/// <param name="previous">上一个</param>
public KeyWordUpdateSetItem(BQLParamHandle parameter, BQLValueItem valueItem, BQLQuery previous)
: base(previous)
{
lstItems = new UpdateSetParamItemList();
lstItems.Add(parameter, valueItem);
}
/// <summary>
/// Set关键字更新的项
/// </summary>
/// <param name="tables">表集合</param>
/// <param name="previous">上一个关键字</param>
internal UpdateSetParamItem(BQLParamHandle parameter, BQLValueItem valueItem)
{
this.parameter = parameter;
this.valueItem = valueItem;
}
/// <summary>
/// 添加一个set项
/// </summary>
/// <param name="parameter">字段</param>
/// <param name="valueItem">值</param>
/// <returns></returns>
public KeyWordUpdateSetItem Set(BQLParamHandle parameter, BQLValueItem valueItem)
{
KeyWordUpdateSetItem item = new KeyWordUpdateSetItem(parameter, valueItem, this);
return(item);
}
/// <summary>
/// 添加一个更新项
/// </summary>
/// <param name="parameter">更新项的字段</param>
/// <param name="valueItem">更新值</param>
public void Add(BQLParamHandle parameter, BQLValueItem valueItem)
{
this.Add(new UpdateSetParamItem(parameter, valueItem));
}
/// <summary>
/// 产生倒叙排序的项
/// </summary>
/// <param name="arg">字段</param>
/// <returns></returns>
public static BQLOrderByHandle DESC(BQLParamHandle arg)
{
BQLOrderByHandle orderHandle = new BQLOrderByHandle(arg, SortType.DESC);
return(orderHandle);
}
/// <summary>
/// 聚合函数
/// </summary>
/// <param name="functionName">函数名</param>
/// <param name="param"></param>
public BQLAggregateFunction(DelAggregateFunctionHandle functionHandle, BQLParamHandle param)
{
this.functionHandle = functionHandle;
this.param = param;
}
/// <summary>
/// 最大
/// </summary>
/// <param name="functionHandle">函数</param>
/// <param name="param">字段</param>
/// <returns></returns>
public static BQLAggregateFunction Max(BQLParamHandle param)
{
BQLAggregateFunction item = new BQLAggregateFunction(DBAggregateFunction.DoMax, param);
return(item);
}
/// <summary>
/// 别名字段
/// </summary>
/// <param name="param">字段</param>
/// <param name="asName">别名</param>
/// <returns></returns>
public static BQLAliasParamHandle ParamAs(BQLParamHandle param, string asName)
{
BQLAliasParamHandle item = new BQLAliasParamHandle(param, asName);
return(item);
}
