/*************************************************************************************************************************************/
internal static ParamInfo EnumParam(DicParam ui, Type realType, Context dc)
{
var type = dc.PH.GetType(ui.ColumnType, realType, dc);
var val = default(object);
//
if (type == DbType.Int32)
{
if (ui.CsValue is string)
{
val = (int)(Enum.Parse(realType, ui.CsValue?.ToString(), true));
}
else if (ui.CsValue == null)
{
val = null;
}
else if (ui.CsValue is int)
{
val = ui.CsValue.ToInt();
}
else
{
val = (int)(ui.CsValue);
}
}
else
{
throw XConfig.EC.Exception(XConfig.EC._051, $"不支持的字段参数类型:[[{realType}]]!");
}
//
return(dc.PH.GetDefault(ui.Param, val, type));
}
private void SelectSpecialDateFormatCol(DicParam dic)
{
if (dic.Crud == CrudEnum.Join)
{
if (dic.Option == OptionEnum.Column)
{
Function(dic.Func, X, DC); LeftRoundBracket(X); DbSql.Column(dic.TbAlias, dic.TbCol, X); Comma(X); StringConst(dic.Format, X); RightRoundBracket(X);
}
else if (dic.Option == OptionEnum.ColumnAs)
{
Function(dic.Func, X, DC); LeftRoundBracket(X); DbSql.Column(dic.TbAlias, dic.TbCol, X); Comma(X); StringConst(dic.Format, X); RightRoundBracket(X);
As(X); DbSql.ColumnAlias(dic.TbColAlias, X);
}
}
else if (dic.Crud == CrudEnum.Query)
{
if (dic.Option == OptionEnum.Column)
{
Function(dic.Func, X, DC); LeftRoundBracket(X); DbSql.Column(string.Empty, dic.TbCol, X); Comma(X); StringConst(dic.Format, X); RightRoundBracket(X);
}
else if (dic.Option == OptionEnum.ColumnAs)
{
Function(dic.Func, X, DC); LeftRoundBracket(X); DbSql.Column(string.Empty, dic.TbCol, X); Comma(X); StringConst(dic.Format, X); RightRoundBracket(X);
As(X); DbSql.ColumnAlias(dic.TbColAlias, X);
}
}
}
internal ParamInfo BoolParam(DicParam ui, Type realType, Context dc)
{
var type = dc.PH.GetType(ui.ColumnType, realType, dc);
var val = default(object);
//
if (type == DbType.UInt16 ||
type == DbType.UInt32 ||
type == DbType.UInt64 ||
type == DbType.Int16 ||
type == DbType.Int32 ||
type == DbType.Int64)
{
if (ui.CsValue.ToBool())
{
val = 1;
}
else
{
val = 0;
}
}
else if (type == DbType.Boolean)
{
val = ui.CsValue.ToBool();
}
else
{
val = ui.CsValue;
}
//
return(dc.PH.GetDefault(ui.Param, val, type));
}
private void LikeStrHandle(DicParam dic)
{
Spacing(X);
var name = dic.Param;
var value = dic.ParamInfo.Value.ToString();
if (!value.Contains("%") &&
!value.Contains("_"))
{
X.Append("CONCAT");
LeftBracket(X); SingleQuote(X); Percent(X); SingleQuote(X); Comma(X); DbParam(name, X); Comma(X); SingleQuote(X); Percent(X); SingleQuote(X); RightBracket(X);
}
else if ((value.Contains("%") || value.Contains("_")) &&
!value.Contains("/%") &&
!value.Contains("/_"))
{
DbParam(name, X);
}
else if (value.Contains("/%") ||
value.Contains("/_"))
{
DbParam(name, X); Spacing(X); Escape(X); Spacing(X); SingleQuote(X); EscapeChar(X); SingleQuote(X);
}
else
{
throw new Exception($"{XConfig.EC._015} -- [[{dic.Action}-{dic.Option}-{value}]] 不能解析!!!");
}
}
private void DbParam(DicParam ui, DicParam refDb)
{
if (ui.IsDbSet)
{
return;
}
ui.IsDbSet = true;
//
if (ui.ClassFullName.IsNullStr())
{
ui.Key = string.Empty;
}
else
{
ui.Key = DC.XC.GetModelKey(ui.ClassFullName);
ui.TableOne = DC.XC.GetTableName(ui.Key);
}
if (ui.CsType != null)
{
if (DC.IsInParameter(ui))
{
ui.ParamInfo = ParameterHelper.GetDefault(ui.Param, ui.CsValue, DbType.String);
}
else
{
DC.PH.GetDbVal(ui, ui.CsType);
}
}
if (ui.Group != null)
{
foreach (var item in ui.Group)
{
DbParam(item, ui);
}
return;
}
ui.GroupRef = refDb;
if (ui.InItems != null)
{
foreach (var u in ui.InItems)
{
DbParam(u, refDb);
}
}
if (ui.Inserts != null)
{
foreach (var u in ui.Inserts)
{
DbParam(u, refDb);
}
}
if (ui.Columns != null)
{
foreach (var u in ui.Columns)
{
DbParam(u, refDb);
}
}
}
private static ParamInfo EnumParam(DicParam ui, Type realType)
{
var type = GetType(ui.ColumnType, realType);
var val = default(object);
//
if (type == DbType.Int32)
{
if (ui.CsValue is string)
{
val = (int)(Enum.Parse(realType, ui.CsValue?.ToString(), true));
}
else if (ui.CsValue == null)
{
val = null;
}
else if (ui.CsValue is int)
{
val = ui.CsValue.ToInt();
}
else
{
val = (int)(ui.CsValue);
}
}
else
{
throw new Exception($"[[ParamInfo EnumParam(ui.ColumnTypeDicModelUI ui, Type realType)]]不支持的字段参数类型:[[{realType}]]!");
}
//
return(GetDefault(ui.Param, val, type));
}
private static ParamInfo BoolParam(DicParam ui, Type realType)
{
var type = GetType(ui.ColumnType, realType);
var val = default(object);
//
if (type == DbType.UInt16)
{
if (ui.CsValue.ToBool())
{
val = 1;
}
else
{
val = 0;
}
}
else if (type == DbType.Boolean)
{
val = ui.CsValue.ToBool();
}
else
{
throw new Exception($"[[ParamInfo BoolParamHandle(ui.ColumnTypeDicModelUI item, Type realType)]]不支持的字段参数类型:[[{realType}]]!");
}
//
return(GetDefault(ui.Param, val, type));
}
private string LikeProcess(DicParam db, bool isMulti)
{
if (isMulti)
{
if (db.Crud == CrudTypeEnum.Join)
{
return($" {db.TableAliasOne}.`{db.ColumnOne}`{Option(db.Option)}{LikeStrHandle(db)} ");
}
else if (DC.IsSingleTableOption())
{
return($" `{db.ColumnOne}`{Option(db.Option)}{LikeStrHandle(db)} ");
}
}
else
{
if (db.Crud == CrudTypeEnum.Join)
{
return($" {Action(db.Action)} {db.TableAliasOne}.`{db.ColumnOne}`{Option(db.Option)}{LikeStrHandle(db)} ");
}
else if (DC.IsSingleTableOption())
{
return($" {Action(db.Action)} `{db.ColumnOne}`{Option(db.Option)}{LikeStrHandle(db)} ");
}
}
throw new Exception("LikeProcess 未能处理!!!");
}
/****************************************************************************************************************************/
private void LikeStrHandle(DicParam dic)
{
Spacing(X);
var name = dic.Param;
var value = dic.ParamInfo.Value.ToString();
if (!value.Contains("%") &&
!value.Contains("_"))
{
X.Append("concat");
LeftRoundBracket(X); StringConst(Percent.ToString(), X); Comma(X); DbSql.DbParam(name, X); Comma(X); StringConst(Percent.ToString(), X); RightRoundBracket(X);
}
else if ((value.Contains("%") || value.Contains("_")) &&
!value.Contains("/%") &&
!value.Contains("/_"))
{
DbSql.DbParam(name, X);
}
else if (value.Contains("/%") ||
value.Contains("/_"))
{
DbSql.DbParam(name, X); Spacing(X); Escape(X); Spacing(X); StringConst(EscapeChar.ToString(), X);
}
else
{
throw XConfig.EC.Exception(XConfig.EC._015, $"{dic.Action}-{dic.Option}-{value}");
}
}
private string InProcess(DicParam db, bool isMulti)
{
if (isMulti)
{
if (db.Crud == CrudTypeEnum.Join)
{
return($" {db.TableAliasOne}.`{db.ColumnOne}` {Function(db.Func)}({InStrHandle(db.InItems)}) ");
}
else if (DC.IsSingleTableOption())
{
return($" `{db.ColumnOne}` {Function(db.Func)}({InStrHandle(db.InItems)}) ");
}
}
else
{
if (db.Crud == CrudTypeEnum.Join)
{
return($" {Action(db.Action)} {db.TableAliasOne}.`{db.ColumnOne}` {Function(db.Func)}({InStrHandle(db.InItems)}) ");
}
else if (DC.IsSingleTableOption())
{
return($" {Action(db.Action)} `{db.ColumnOne}` {Function(db.Func)}({InStrHandle(db.InItems)}) ");
}
}
throw new Exception("InProcess 未能处理!!!");
}
internal void GetParamInfo(DicParam ui, Type realType)
{
//
if (DC.IsParameter(ui.Action))
{
//
if (ui.Option == OptionEnum.OneEqualOne)
{
}
else if (ui.Action == ActionEnum.SQL)
{
ui.ColumnType = ui.ParamUI.ParamType;
}
else
{
var tbm = DC.XC.GetTableModel(ui.TbMType);
var col = tbm.TbCols.FirstOrDefault(it => it.ColumnName.Equals(ui.TbCol, StringComparison.OrdinalIgnoreCase));
if (col != null)
{
ui.ColumnType = GetColType(col.DataType, DC);
}
}
//
var para = default(ParamInfo);
if (realType == null &&
ui.Action == ActionEnum.SQL)
{
para = NullParam(ui, realType, DC);
}
else if (XConfig.ParamFuncs.TryGetValue(realType, out var func))
{
para = func(ui, realType, DC);
}
else if (realType.IsEnum)
{
para = EnumParam(ui, realType, DC);
}
else if (realType.IsNullable())
{
var type = Nullable.GetUnderlyingType(realType);
if (ui.CsValue == null)
{
para = NullParam(ui, type, DC);
}
else
{
GetParamInfo(ui, type);
return;
}
}
else
{
throw XConfig.EC.Exception(XConfig.EC._033, $"不支持的字段参数类型:[[{realType}]]!");
}
//
ui.ParamInfo = para;
}
}
private string DateFormatProcess(DicParam db, bool isMulti)
{
if (isMulti)
{
if (db.Crud == CrudTypeEnum.Join)
{
return($" {Function(db.Func)}({db.TableAliasOne}.`{db.ColumnOne}`,'{db.Format}'){Compare(db.Compare)}@{db.Param} ");
}
else if (DC.IsSingleTableOption())
{
return($" {Function(db.Func)}(`{db.ColumnOne}`,'{db.Format}'){Compare(db.Compare)}@{db.Param} ");
}
}
else
{
if (db.Crud == CrudTypeEnum.Join)
{
return($" {Action(db.Action)} {Function(db.Func)}({db.TableAliasOne}.`{db.ColumnOne}`,'{db.Format}'){Compare(db.Compare)}@{db.Param} ");
}
else if (DC.IsSingleTableOption())
{
return($" {Action(db.Action)} {Function(db.Func)}(`{db.ColumnOne}`,'{db.Format}'){Compare(db.Compare)}@{db.Param} ");
}
}
throw new Exception("DateFormatProcess 未能处理!!!");
}
private void Unique(DicParam dic)
{
//
dic.ID = DC.DicID;
DC.DicID++;
if (!dic.ParamRaw.IsNullStr())
{
dic.Param = $"{dic.ParamRaw}__{dic.ID}";
}
//
if (DC.IsInParameter(dic))
{
InNotIn(dic);
}
else if (dic.Group != null)
{
foreach (var ui in dic.Group)
{
if (DC.IsInParameter(ui))
{
ui.InItems = new List <DicParam>();
}
Unique(ui);
ui.GroupRef = dic;
}
}
}
private void SelectSpecialNoFuncCol(DicParam dic)
{
if (dic.Crud == CrudEnum.Join)
{
if (dic.Option == OptionEnum.Column)
{
DbSql.Column(dic.TbAlias, dic.TbCol, X);
}
else if (dic.Option == OptionEnum.ColumnAs)
{
DbSql.Column(dic.TbAlias, dic.TbCol, X); As(X); DbSql.ColumnAlias(dic.TbColAlias, X);
}
}
else if (dic.Crud == CrudEnum.Query)
{
if (dic.Option == OptionEnum.Column)
{
DbSql.Column(string.Empty, dic.TbCol, X);
}
else if (dic.Option == OptionEnum.ColumnAs)
{
DbSql.Column(string.Empty, dic.TbCol, X); As(X); DbSql.ColumnAlias(dic.TbColAlias, X);
}
}
}
/****************************************************************************************************************************/
private void CompareProcess(DicParam db)
{
if (db.Compare == CompareXEnum.In ||
db.Compare == CompareXEnum.NotIn)
{
InProcess(db);
}
else if (db.Compare == CompareXEnum.Like ||
db.Compare == CompareXEnum.NotLike)
{
LikeProcess(db);
}
else
{
Spacing(X);
if (db.Crud == CrudEnum.Join)
{
DbSql.Column(db.TbAlias, db.TbCol, X);
}
else if (DC.IsSingleTableOption())
{
DbSql.Column(string.Empty, db.TbCol, X);
}
Compare(db.Compare, X, DC); DbSql.DbParam(db.Param, X);
}
}
/****************************************************************************************************************/
private string CompareProcess(DicParam db, bool isMulti)
{
if (isMulti)
{
if (db.Crud == CrudTypeEnum.Join)
{
return($" {db.TableAliasOne}.`{db.ColumnOne}`{Compare(db.Compare)}@{db.Param} ");
}
else if (DC.IsSingleTableOption())
{
return($" `{db.ColumnOne}`{Compare(db.Compare)}@{db.Param} ");
}
}
else
{
if (db.Crud == CrudTypeEnum.Join)
{
return($" {Action(db.Action)} {db.TableAliasOne}.`{db.ColumnOne}`{Compare(db.Compare)}@{db.Param} ");
}
else if (DC.IsSingleTableOption())
{
return($" {Action(db.Action)} `{db.ColumnOne}`{Compare(db.Compare)}@{db.Param} ");
}
}
throw new Exception("CompareProcess 未能处理!!!");
}
public Param(DicParam dic, String nom, String expression)
{
_Dic = dic;
Nom = nom;
Expression = expression;
AjouterDic();
}
internal protected static bool IsCountParam(DicParam param)
{
if (param.Option == OptionEnum.Column &&
param.Func == FuncEnum.Count)
{
return(true);
}
return(false);
}
private void DbParam(DicParam ui, DicParam refDb)
{
if (ui.IsDbSet)
{
return;
}
ui.IsDbSet = true;
//
if (ui.Crud == CrudEnum.SQL)
{
DC.PH.GetParamInfo(ui, ui.CsType);
return;
}
if (ui.CsType != null)
{
if (DC.IsInParameter(ui))
{
ui.ParamInfo = DC.PH.GetDefault(ui.Param, ui.CsValue, DbType.String);
}
else
{
DC.PH.GetParamInfo(ui, ui.CsType);
}
}
if (ui.Group != null)
{
foreach (var item in ui.Group)
{
DbParam(item, ui);
}
return;
}
ui.GroupRef = refDb;
if (ui.InItems != null)
{
foreach (var u in ui.InItems)
{
DbParam(u, refDb);
}
}
if (ui.Inserts != null)
{
foreach (var u in ui.Inserts)
{
DbParam(u, refDb);
}
}
if (ui.Columns != null)
{
foreach (var u in ui.Columns)
{
DbParam(u, refDb);
}
}
}
internal protected static bool IsOrderByParam(DicParam param)
{
if (param.Action == ActionEnum.OrderBy &&
(param.Func == FuncEnum.None ||
param.Func == FuncEnum.CharLength))
{
return(true);
}
return(false);
}
internal protected static bool IsSelectColumnParam(DicParam param)
{
if (param.Action == ActionEnum.Select &&
(param.Option == OptionEnum.Column || param.Option == OptionEnum.ColumnAs) &&
param.Columns != null)
{
return(true);
}
return(false);
}
/****************************************************************************************************************************/
internal protected static bool IsDistinctParam(DicParam param)
{
if (param.Action == ActionEnum.Select &&
param.Option == OptionEnum.ColumnOther &&
param.Compare == CompareXEnum.Distinct)
{
return(true);
}
return(false);
}
private static bool IsWhere(DicParam p)
{
if (p.Action == ActionEnum.Where ||
p.Action == ActionEnum.And ||
p.Action == ActionEnum.Or)
{
return(true);
}
return(false);
}
private void InNotIn(DicParam dic)
{
var vals = dic.CsValue.ToString().Split(',').Select(it => it);
foreach (var val in vals)
{
var dicx = InHelper(dic, val, dic.CsValueStr);
Unique(dicx);
dic.InItems.Add(dicx);
}
}
/************************************************************************************************************************/
internal bool IsInParameter(DicParam dic)
{
if (dic.Group == null &&
dic.CsValue != null &&
dic.Option == OptionEnum.Compare &&
(dic.Compare == CompareXEnum.In || dic.Compare == CompareXEnum.NotIn))
{
return(true);
}
return(false);
}
/************************************************************************************************************************/
internal bool IsInParameter(DicParam dic)
{
if (dic.Group == null &&
dic.CsValue != null &&
dic.Option == OptionEnum.Function &&
(dic.Func == FuncEnum.In || dic.Func == FuncEnum.NotIn))
{
return(true);
}
return(false);
}
private string IsNullProcess(DicParam db, bool isMulti)
{
if (isMulti)
{
return($" `{db.ColumnOne}` {Option(db.Option)} ");
}
else
{
return($" {Action(db.Action)} `{db.ColumnOne}` {Option(db.Option)} ");
}
throw new Exception("IsNullProcess 未能处理!!!");
}
private string OneEqualOneProcess(DicParam db, bool isMulti)
{
if (isMulti)
{
return($" @{db.Param} ");
}
else
{
return($" {Action(db.Action)} @{db.Param} ");
}
throw new Exception("OneEqualOneProcess 未能处理!!!");
}
public Param(DicParam dic, String ligne)
{
_Dic = dic;
String[] tab = ligne.Split(new Char[] { ':' }, StringSplitOptions.None);
if (tab.Length == 2)
{
Nom = tab[0].Trim();
Expression = tab[1].Trim();
AjouterDic();
}
}
internal void AddParameter(DicParam dic)
{
if (DC.IsInParameter(dic))
{
dic.InItems = new List <DicParam>();
}
Unique(dic);
DC.Parameters.Add(dic);
//
DC.Compare = CompareEnum.None;
DC.Func = FuncEnum.None;
}
