public void ItShouldBeAbleToParameterizeAQuery()
{
var ageParam = new ExpressionParameter<int>("age");
var expr = Select.Star<Person>()
.From<Person>()
.Where<Person>(p => p.Age > ageParam);
var result = expr.ToSqlExpression();
Assert.That(result, Is.EqualTo(TokenGeneration_ParametrizedQueryTests_Result.parameterizedExpression));
}
public void ItShouldBePossibleToUseTheParameterInMoreComplexExpressions()
{
var ageParam = new ExpressionParameter<int>("age");
var expr = Select.Star<Person>()
.From<Person>()
.Where<Person>(p => p.Age > ageParam && ageParam < 90)
.Or<Person>(p => p.Age < ageParam);
var result = expr.ToSqlExpression();
Assert.That(result, Is.EqualTo(TokenGeneration_ParametrizedQueryTests_Result.complexParameterizedExpression));
}
protected void AppendMember(ExpressionParameter parameter, bool?isLeft, object appendValue)
{
Context.ParameterIndex++;
if (isLeft == true)
{
appendValue += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
}
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
{
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue.ObjToString());
}
else
{
this.Context.Result.Append(appendValue);
}
}
public void ItShouldBeAbleToVisitParameters()
{
var ageParam = new ExpressionParameter <int>("ageparam");
Expression <Func <Person, bool> > func = (Person p) => p.Age != ageParam;
var tableRefs = new[]
{
Types.TableReferenceFromType <Person>(),
};
var ev = ExpressionVisitor.Visit(
ExpressionVisitor.VisitableExpression.NewLinqExpression(func),
tableRefs.ToContext());
var expected =
S.BinExp(S.Col <Person>("Age"), BinaryOperation.NotEqual, S.Param("ageparam")).ToOption();
Assert.That(ev, Is.EqualTo(expected));
}
public void Apply()
{
EditorUtility.DisplayProgressBar("Remove Exiting Items", "", 0f);
var bitActionSwitchAnimator =
new BitActionSwitchAnimatorCreator(this.animatorController);
bitActionSwitchAnimator.RemoveExistBitActionSwitchAnimator();
var expressionParameter = new ExpressionParameter(this.expressionParameters);
expressionParameter.RemoveExistExpressionParameters();
GlobalClips.ShortEmptyClip =
ActivationClip.CreateEmptyClip(this.workingDirectory, "ShortWait", 0.00f, 0.01f);
for (var i = 0; i < this.bitActionSwitch.bitActionSwitchGroups.Count; i++)
{
var progress = (float)i / this.bitActionSwitch.bitActionSwitchGroups.Count;
var info = $"{i + 1} / {this.bitActionSwitch.bitActionSwitchGroups.Count}({progress * 100:F2}%)";
EditorUtility.DisplayProgressBar($"Create Group{i + 1}", info, progress);
var bitActionSwitchGroup = this.bitActionSwitch.bitActionSwitchGroups[i];
if (!bitActionSwitchGroup.variableName.StartsWith(ActionSwitchParameters.PREFIX))
{
bitActionSwitchGroup.variableName = $"{ActionSwitchParameters.PREFIX}{bitActionSwitchGroup.variableName}";
}
var expressionMenu = new ExpressionMenu(bitActionSwitchGroup.expressionsMenu);
expressionMenu.RemoveExistExpressionMenuControls();
expressionParameter.AddExpressionParameters(bitActionSwitchGroup.variableName);
var animationClips = this.CreateAnimationClips(bitActionSwitchGroup, i);
for (var j = 0; j < bitActionSwitchGroup.bitActionSwitchItems.Count; j++)
{
expressionMenu.AddExpressionMenuControl(bitActionSwitchGroup.bitActionSwitchItems[j], j + 1 + i * 9);
}
bitActionSwitchAnimator.CreateBitActionSwitchAnimator(animationClips, bitActionSwitchGroup, i);
}
EditorUtility.ClearProgressBar();
}
private void Update(MemberInitExpression expression, ExpressionParameter parameter)
{
int i = 0;
foreach (MemberBinding binding in expression.Bindings)
{
++i;
if (binding.BindingType != MemberBindingType.Assignment)
{
throw new NotSupportedException();
}
MemberAssignment memberAssignment = (MemberAssignment)binding;
var memberName = memberAssignment.Member.Name;
var item = memberAssignment.Expression;
if (item is MethodCallExpression)
{
base.Expression = item;
base.Start();
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameter.CommonTempData.ObjToString()));
}
else if (item is MemberExpression)
{
if (base.Context.Result.IsLockCurrentParameter == false)
{
base.Context.Result.CurrentParameter = parameter;
base.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
base.Expression = item;
base.Start();
parameter.IsAppendResult();
parameter.Context.Result.Append(base.Context.GetEqString(memberName, parameter.CommonTempData.ObjToString()));
base.Context.Result.CurrentParameter = null;
}
}
else if (item is BinaryExpression)
{
var result = GetNewExpressionValue(item);
this.Context.Result.Append(base.Context.GetEqString(memberName, result));
}
}
}
public NewExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var expression = base.Expression as NewExpression;
switch (parameter.Context.ResolveType)
{
case ResolveExpressType.WhereSingle:
// Check.ThrowNotSupportedException(expression.ToString());
break;
case ResolveExpressType.WhereMultiple:
// Check.ThrowNotSupportedException(expression.ToString());
break;
case ResolveExpressType.SelectSingle:
// Check.Exception(expression.Type == UtilConstants.DateType, "ThrowNotSupportedException {0} ",expression.ToString());
Select(expression, parameter, true);
break;
case ResolveExpressType.SelectMultiple:
// Check.Exception(expression.Type == UtilConstants.DateType, "ThrowNotSupportedException {0} ", expression.ToString());
Select(expression, parameter, false);
break;
case ResolveExpressType.FieldSingle:
// Check.ThrowNotSupportedException(expression.ToString());
break;
case ResolveExpressType.FieldMultiple:
case ResolveExpressType.ArrayMultiple:
case ResolveExpressType.ArraySingle:
foreach (var item in expression.Arguments)
{
base.Expression = item;
base.Start();
}
break;
default:
break;
}
}
public MethodCallExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var express = base.Expression as MethodCallExpression;
var isLeft = parameter.IsLeft;
string methodName = express.Method.Name;
var isValidNativeMethod = MethodMapping.ContainsKey(methodName) && express.Method.DeclaringType.Namespace == ("System");
List <MethodCallExpressionArgs> appendArgs = null;
if (MethodTimeMapping.ContainsKey(methodName))
{
appendArgs = new List <MethodCallExpressionArgs>();
var dateType = MethodTimeMapping[methodName];
string paramterName = this.Context.SqlParameterKeyWord + "Const" + this.Context.ParameterIndex;
appendArgs.Add(new MethodCallExpressionArgs()
{
IsMember = false, MemberName = paramterName, MemberValue = dateType
});
this.Context.Parameters.Add(new Parameter(paramterName, dateType.ToString()));
this.Context.ParameterIndex++;
methodName = "DateAdd";
isValidNativeMethod = true;
}
else if (methodName == "NewGuid")
{
this.Context.Result.Append(this.Context.DbMehtods.GuidNew());
return;
}
if (!isValidNativeMethod && express.Method.DeclaringType.Namespace.IsIn("System.Linq", "System.Collections.Generic") && methodName == "Contains")
{
methodName = "ContainsArray";
isValidNativeMethod = true;
}
if (isValidNativeMethod)
{
NativeExtensionMethod(parameter, express, isLeft, MethodMapping[methodName], appendArgs);
}
else
{
SqlFuncMethod(parameter, express, isLeft);
}
}
public TypeParameterExpressionReolve(ExpressionParameter parameter) : base(parameter)
{
var expression = (ParameterExpression)base.Expression;
switch (parameter.Context.ResolveType)
{
case ResolveExpressType.WhereSingle:
break;
case ResolveExpressType.WhereMultiple:
break;
case ResolveExpressType.Update:
parameter.BaseParameter.CommonTempData = expression.Name;
break;
case ResolveExpressType.SelectSingle:
case ResolveExpressType.SelectMultiple:
if (parameter.BaseParameter != null && parameter.BaseParameter.CurrentExpression.NodeType == ExpressionType.Lambda)
{
this.Context.Result.Append(expression.Name + ".*");
}
else
{
parameter.BaseParameter.CommonTempData = expression.Name;
}
break;
case ResolveExpressType.FieldSingle:
break;
case ResolveExpressType.FieldMultiple:
break;
case ResolveExpressType.Join:
break;
default:
break;
}
}
protected MethodCallExpressionArgs GetMethodCallArgs(ExpressionParameter parameter, Expression item)
{
var newContext = this.Context.GetCopyContext();
newContext.MappingColumns = this.Context.MappingColumns;
newContext.MappingTables = this.Context.MappingTables;
newContext.Resolve(item, this.Context.IsJoin ? ResolveExpressType.WhereMultiple : ResolveExpressType.WhereSingle);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.IsValuable())
{
this.Context.Parameters.AddRange(newContext.Parameters);
}
var methodCallExpressionArgs = new MethodCallExpressionArgs()
{
IsMember = true,
MemberName = newContext.Result.GetResultString()
};
return(methodCallExpressionArgs);
}
private void FunctionCheckFormLoad(object sender, EventArgs e)
{
SetupGrid();
var ptrs = new List<ExpressionParameter>();
// ReSharper disable LoopCanBeConvertedToQuery
foreach (var var in resolver.GetVariableNames())
// ReSharper restore LoopCanBeConvertedToQuery
{
var varName = var;
var field = PerformerStatField.fields.FirstOrDefault(f =>
!string.IsNullOrEmpty(f.ExpressionParamName) && f.ExpressionParamName.Equals(
varName, StringComparison.OrdinalIgnoreCase));
var fieldTitle = field == null ? "" : field.ExpressionParamTitle;
var ptr = new ExpressionParameter
{
Name = var,
Description = fieldTitle
};
ptrs.Add(ptr);
}
grid.DataBind(ptrs);
}
public ConditionalExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var express = base.Expression as ConditionalExpression;
var isLeft = parameter.IsLeft;
switch (base.Context.ResolveType)
{
case ResolveExpressType.None:
case ResolveExpressType.WhereSingle:
case ResolveExpressType.WhereMultiple:
case ResolveExpressType.SelectSingle:
case ResolveExpressType.SelectMultiple:
case ResolveExpressType.FieldSingle:
case ResolveExpressType.FieldMultiple:
case ResolveExpressType.Join:
case ResolveExpressType.ArraySingle:
case ResolveExpressType.ArrayMultiple:
case ResolveExpressType.Update:
default:
// Check.Exception(true, "Does not support it.xx==value ? true:false , Use SqlFunc.IIF (it.xx==value,true,false)");
break;
}
}
private void FunctionCheckFormLoad(object sender, EventArgs e)
{
SetupGrid();
var ptrs = new List <ExpressionParameter>();
// ReSharper disable LoopCanBeConvertedToQuery
foreach (var var in resolver.GetVariableNames())
// ReSharper restore LoopCanBeConvertedToQuery
{
var varName = var;
var field = PerformerStatField.fields.FirstOrDefault(f =>
!string.IsNullOrEmpty(f.ExpressionParamName) && f.ExpressionParamName.Equals(
varName, StringComparison.OrdinalIgnoreCase));
var fieldTitle = field == null ? "" : field.ExpressionParamTitle;
var ptr = new ExpressionParameter
{
Name = var,
Description = fieldTitle
};
ptrs.Add(ptr);
}
grid.DataBind(ptrs);
}
public bool Deserialize(IParser reader, Type expectedType, Func <IParser, Type, object?> nestedObjectDeserializer, out object?value)
{
value = default;
if (expectedType != typeof(VariableParameter) && expectedType != typeof(ExpressionParameter))
{
return(false);
}
var argument = reader.Consume <Scalar>();
if (expectedType == typeof(VariableParameter))
{
value = new VariableParameter(argument.Value);
}
else if (expectedType == typeof(ExpressionParameter))
{
value = new ExpressionParameter(argument.Value);
}
else
{
return(false);
}
return(true);
}
public void ItShouldBeAbleToVisitParameters()
{
var ageParam = new ExpressionParameter<int>("ageparam");
Expression<Func<Person, bool>> func = (Person p) => p.Age != ageParam;
var tableRefs = new[]
{
Types.TableReferenceFromType<Person>(),
};
var ev = ExpressionVisitor.Visit(
ExpressionVisitor.VisitableExpression.NewLinqExpression(func),
tableRefs.ToContext());
var expected =
S.BinExp(S.Col<Person>("Age"), BinaryOperation.NotEqual, S.Param("ageparam")).ToOption();
Assert.That(ev, Is.EqualTo(expected));
}
public void ItShouldBePossibleToRunAQueryWithParameters()
{
var factory = new HyperboliqConnectionFactory(SqlLite.Dialect, "Data source=:memory:");
using (var con = factory.OpenDbConnection())
{
const string createTable = "CREATE TABLE Person (Id INT, Name VARCHAR(50), Age INT, LivesAtHouseId INT, ParentId INT)";
var cmd1 = con.AsIDbConnection().CreateCommand();
cmd1.CommandText = createTable;
cmd1.ExecuteNonQuery();
var insertQuery = Insert.Into<Person>().AllColumns.Values(new Person { Id = 1, Name = "Kalle", Age = 42 });
con.ExecuteNonQuery(insertQuery);
var nameParam = new ExpressionParameter<string>("name");
var selectQuery = Select.Star<Person>().From<Person>().Where<Person>(p => p.Name == nameParam);
nameParam.SetValue("Kalle");
var persons = con.Query<Person>(selectQuery, nameParam);
Assert.That(persons, Has.Count.EqualTo(1));
var person = persons.First();
Assert.That(person.Id, Is.EqualTo(1));
Assert.That(person.Name, Is.EqualTo("Kalle"));
Assert.That(person.Age, Is.EqualTo(42));
}
}
public BlockExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
}
public IList <AParameter> ConvertParameters(
IList <ParameterNode> parameters,
string resourcePrefix = ""
)
{
var resultList = new List <AParameter>();
if ((parameters == null) || !parameters.Any())
{
return(resultList);
}
// convert all parameters
var index = 0;
foreach (var parameter in parameters)
{
++index;
var parameterName = parameter.Name ?? $"[{index}]";
AParameter result = null;
var parameterFullName = resourcePrefix + parameter.Name;
AtLocation(parameterName, () => {
if (parameter.Secret != null)
{
// encrypted value
AtLocation("Secret", () => {
result = new SecretParameter {
Name = parameter.Name,
Description = parameter.Description,
Secret = parameter.Secret,
Export = parameter.Export,
EncryptionContext = parameter.EncryptionContext
};
});
}
else if (parameter.Values != null)
{
// list of values
AtLocation("Values", () => {
result = new StringListParameter {
Name = parameter.Name,
Description = parameter.Description,
Values = parameter.Values,
Export = parameter.Export
};
});
// TODO (2018-08-19, bjorg): this implementation creates unnecessary parameters
if (parameter.Resource != null)
{
AtLocation("Resource", () => {
// enumerate individual values with resource definition for each
parameter.Parameters = new List <ParameterNode>();
for (var i = 1; i <= parameter.Values.Count; ++i)
{
parameter.Parameters.Add(new ParameterNode {
Name = $"Index{i}",
Value = parameter.Values[i - 1],
Resource = parameter.Resource
});
}
});
}
}
else if (parameter.Package != null)
{
// package value
result = new PackageParameter {
Name = parameter.Name,
Description = parameter.Description,
DestinationBucketParameterName = parameter.Package.Bucket,
DestinationKeyPrefix = parameter.Package.Prefix ?? "",
PackagePath = parameter.Package.PackagePath
};
}
else if (parameter.Value != null)
{
if (parameter.Resource != null)
{
AtLocation("Resource", () => {
// existing resource
var resource = ConvertResource((string)parameter.Value, parameter.Resource);
result = new ReferencedResourceParameter {
Name = parameter.Name,
Description = parameter.Description,
Resource = resource
};
});
}
else if (parameter.Value is string text)
{
// plaintext value
result = new StringParameter {
Name = parameter.Name,
Description = parameter.Description,
Value = text
};
}
else
{
// plaintext value
result = new ExpressionParameter {
Name = parameter.Name,
Description = parameter.Description,
Expression = parameter.Value
};
}
}
else if (parameter.Resource != null)
{
// managed resource
AtLocation("Resource", () => {
result = new CloudFormationResourceParameter {
Name = parameter.Name,
Description = parameter.Description,
Resource = ConvertResource(null, parameter.Resource)
};
});
}
});
// check if there are nested parameters
if (parameter.Parameters != null)
{
AtLocation("Parameters", () => {
var nestedParameters = ConvertParameters(
parameter.Parameters,
parameterFullName
);
// keep nested parameters only if they have values
if (nestedParameters.Any())
{
// create empty string parameter if collection has no value
result = result ?? new StringParameter {
Name = parameter.Name,
Value = "",
Description = parameter.Description,
Export = parameter.Export
};
result.Parameters = nestedParameters;
}
});
}
// add parameter
if (result != null)
{
result.FullName = parameterFullName;
result.Export = parameter.Export;
resultList.Add(result);
}
}
return(resultList);
}
private void AppendModelByIIFBinary(ExpressionParameter parameter, MethodCallExpressionModel model, Expression item)
{
//Check.Exception(true, "The SqlFunc.IIF(arg1,arg2,arg3) , {0} argument do not support ", item.ToString());
}
protected void AppendValue(ExpressionParameter parameter, bool?isLeft, object value)
{
if (parameter.BaseExpression is BinaryExpression || parameter.BaseExpression == null)
{
var oppoSiteExpression = isLeft == true ? parameter.BaseParameter.RightExpression : parameter.BaseParameter.LeftExpression;
if (parameter.CurrentExpression is MethodCallExpression)
{
var appendValue = value;
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
{
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue.ObjToString());
}
else
{
this.Context.Result.Append(appendValue);
}
this.AppendOpreator(parameter, isLeft);
}
else if (oppoSiteExpression is MemberExpression)
{
string appendValue = Context.SqlParameterKeyWord
+ ((MemberExpression)oppoSiteExpression).Member.Name
+ Context.ParameterIndex;
if (value.ObjToString() != "NULL" && !parameter.ValueIsNull)
{
this.Context.Parameters.Add(new Parameter(appendValue, value));
}
else
{
appendValue = value.ObjToString();
}
Context.ParameterIndex++;
appendValue = string.Format(" {0} ", appendValue);
if (isLeft == true)
{
appendValue += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
}
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
{
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue);
}
else
{
this.Context.Result.Append(appendValue);
}
}
else if ((oppoSiteExpression is UnaryExpression && (oppoSiteExpression as UnaryExpression).Operand is MemberExpression))
{
string appendValue = Context.SqlParameterKeyWord
+ ((MemberExpression)(oppoSiteExpression as UnaryExpression).Operand).Member.Name
+ Context.ParameterIndex;
if (value.ObjToString() != "NULL" && !parameter.ValueIsNull)
{
this.Context.Parameters.Add(new Parameter(appendValue, value));
}
else
{
appendValue = value.ObjToString();
}
Context.ParameterIndex++;
appendValue = string.Format(" {0} ", appendValue);
if (isLeft == true)
{
appendValue += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
}
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
{
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue);
}
else
{
this.Context.Result.Append(appendValue);
}
}
else
{
var appendValue = this.Context.SqlParameterKeyWord + ExpressionConst.Const + Context.ParameterIndex;
Context.ParameterIndex++;
if (value != null && value.GetType().IsEnum())
{
value = Convert.ToInt64(value);
}
this.Context.Parameters.Add(new Parameter(appendValue, value));
appendValue = string.Format(" {0} ", appendValue);
if (isLeft == true)
{
appendValue += ExpressionConst.ExpressionReplace + parameter.BaseParameter.Index;
}
if (this.Context.Result.Contains(ExpressionConst.FormatSymbol))
{
this.Context.Result.Replace(ExpressionConst.FormatSymbol, appendValue);
}
else
{
this.Context.Result.Append(appendValue);
}
}
}
}
/// <summary>
/// 表达式成员集合
/// </summary>
/// <param name="type"></param>
/// <param name="memberNodeTypeName"></param>
internal ExpressionMemberGroup(ExtensionType type, string memberNodeTypeName)
{
this.type = type;
this.memberNodeTypeName = memberNodeTypeName;
LeftArray <Expression> members = new LeftArray <Expression>(0);
nodeTypeNames.Clear();
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Instance, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
IsMember &= addMember(ref members, new Expression {
Attribute = attribute, Member = member, IntputParameters = member.IsField ? EmptyArray <ExpressionParameter> .Array : ExpressionParameter.Get(MethodParameter.Get(((PropertyInfo)member.Member).GetGetMethod(true), EmptyArray <Type> .Array))
});
}
}
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Instance, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
IsMember &= addMember(ref members, new Expression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
Members = members.ToArray();
if (memberNodeTypeName == null)
{
LeftArray <StaticExpression> staticMembers = new LeftArray <StaticExpression>(0);
foreach (MemberIndex member in MemberIndex.GetStaticMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Static, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
IsMember &= addMember(ref staticMembers, new StaticExpression {
Attribute = attribute, Member = member, IntputParameters = EmptyArray <ExpressionParameter> .Array
});
}
}
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(type, AutoCSer.Metadata.MemberFilters.Static, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
IsMember &= addMember(ref staticMembers, new StaticExpression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
StaticMembers = staticMembers.ToArray();
}
else
{
StaticMembers = EmptyArray <StaticExpression> .Array;
}
if ((IsMember &= (Members.Length | StaticMembers.Length) != 0) && memberNodeTypeName == null)
{
foreach (Expression member in Members)
{
member.CheckGenericMemberGroup();
}
foreach (StaticExpression member in StaticMembers)
{
member.CheckGenericMemberGroup();
}
}
}
public MemberExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var baseParameter = parameter.BaseParameter;
var isLeft = parameter.IsLeft;
var isSetTempData = baseParameter.CommonTempData.IsValuable();
var expression = base.Expression as MemberExpression;
var childExpression = expression.Expression as MemberExpression;
var childIsMember = childExpression != null;
var isValue = expression.Member.Name == "Value" && expression.Member.DeclaringType.Name == "Nullable`1";
var isBool = expression.Type == UtilConstants.BoolType;
var isValueBool = isValue && isBool && parameter.BaseExpression == null;
var isLength = expression.Member.Name == "Length" && childIsMember && childExpression.Type == UtilConstants.StringType;
var isDateValue = expression.Member.Name.IsIn(Enum.GetNames(typeof(DateType))) && (expression.Expression as MemberExpression).Type == UtilConstants.DateType;
var isLogicOperator = ExpressionTool.IsLogicOperator(baseParameter.OperatorValue) || baseParameter.OperatorValue.IsNullOrEmpty();
var isHasValue = isLogicOperator && expression.Member.Name == "HasValue" && expression.Expression != null && expression.NodeType == ExpressionType.MemberAccess;
var isDateTimeNowDate = expression.Member.Name == "Date" && childIsMember && childExpression.Member.Name == "Now";
var isDateDate = expression.Member.Name == "Date" && expression.Expression.Type == UtilConstants.DateType;
if (isLength)
{
var oldCommonTempDate = parameter.CommonTempData;
this.Expression = expression.Expression;
var isConst = this.Expression is ConstantExpression;
this.Start();
var methodParamter = new MethodCallExpressionArgs()
{
IsMember = !isConst, MemberName = parameter.CommonTempData, MemberValue = null
};
var result = this.Context.DbMehtods.Length(new MethodCallExpressionModel()
{
Args = new List <MethodCallExpressionArgs>()
{
methodParamter
}
});
base.AppendMember(parameter, isLeft, result);
parameter.CommonTempData = oldCommonTempDate;
return;
}
else if (isHasValue)
{
this.Expression = expression.Expression;
this.Start();
var methodParamter = new MethodCallExpressionArgs()
{
IsMember = true, MemberName = parameter.CommonTempData, MemberValue = null
};
var result = this.Context.DbMehtods.HasValue(new MethodCallExpressionModel()
{
Args = new List <MethodCallExpressionArgs>()
{
methodParamter
}
});
this.Context.Result.Append(result);
parameter.CommonTempData = null;
return;
}
else if (isDateValue)
{
var name = expression.Member.Name;
var oldCommonTempDate = parameter.CommonTempData;
this.Expression = expression.Expression;
var isConst = this.Expression is ConstantExpression;
this.Start();
var result = this.Context.DbMehtods.DateValue(new MethodCallExpressionModel()
{
Args = new List <MethodCallExpressionArgs>()
{
new MethodCallExpressionArgs()
{
IsMember = !isConst, MemberName = parameter.CommonTempData, MemberValue = null
},
new MethodCallExpressionArgs()
{
IsMember = true, MemberName = name, MemberValue = name
}
}
});
base.AppendMember(parameter, isLeft, result);
parameter.CommonTempData = oldCommonTempDate;
return;
}
else if (isValueBool)
{
isValue = false;
}
else if (isValue)
{
expression = expression.Expression as MemberExpression;
}
else if (isDateDate)
{
var name = expression.Member.Name;
var oldCommonTempDate = parameter.CommonTempData;
this.Expression = expression.Expression;
this.Start();
var isConst = parameter.CommonTempData.GetType() == UtilConstants.DateType;
if (isConst)
{
AppendValue(parameter, isLeft, parameter.CommonTempData.ObjToDate().Date);
}
else
{
var GetYear = new MethodCallExpressionModel()
{
Args = new List <MethodCallExpressionArgs>()
{
new MethodCallExpressionArgs()
{
IsMember = true, MemberName = parameter.CommonTempData, MemberValue = parameter.CommonTempData
},
new MethodCallExpressionArgs()
{
MemberName = DateType.Year, MemberValue = DateType.Year
}
}
};
AppendMember(parameter, isLeft, GetToDate(this.Context.DbMehtods.MergeString(
this.GetDateValue(parameter.CommonTempData, DateType.Year),
"+'-'+",
this.GetDateValue(parameter.CommonTempData, DateType.Month),
"+'-'+",
this.GetDateValue(parameter.CommonTempData, DateType.Day))));
}
parameter.CommonTempData = oldCommonTempDate;
return;
}
else if (isDateTimeNowDate)
{
AppendValue(parameter, isLeft, DateTime.Now.Date);
return;
}
else if (expression.Expression != null && expression.Expression.NodeType != ExpressionType.Parameter && !isValueBool)
{
var value = ExpressionTool.GetMemberValue(expression.Member, expression);
if (isSetTempData)
{
baseParameter.CommonTempData = value;
}
else
{
AppendValue(parameter, isLeft, value);
}
return;
}
string fieldName = string.Empty;
baseParameter.ChildExpression = expression;
switch (parameter.Context.ResolveType)
{
case ResolveExpressType.SelectSingle:
fieldName = GetSingleName(parameter, expression, isLeft);
if (isSetTempData)
{
baseParameter.CommonTempData = fieldName;
}
else
{
base.Context.Result.Append(fieldName);
}
break;
case ResolveExpressType.SelectMultiple:
fieldName = GetMultipleName(parameter, expression, isLeft);
if (isSetTempData)
{
baseParameter.CommonTempData = fieldName;
}
else
{
base.Context.Result.Append(fieldName);
}
break;
case ResolveExpressType.WhereSingle:
case ResolveExpressType.WhereMultiple:
var isSingle = parameter.Context.ResolveType == ResolveExpressType.WhereSingle;
if (isSetTempData)
{
fieldName = GetName(parameter, expression, null, isSingle);
baseParameter.CommonTempData = fieldName;
}
else
{
if (isValueBool)
{
fieldName = GetName(parameter, expression.Expression as MemberExpression, isLeft, isSingle);
}
else if (ExpressionTool.IsConstExpression(expression))
{
var value = ExpressionTool.GetMemberValue(expression.Member, expression);
base.AppendValue(parameter, isLeft, value);
return;
}
else
{
fieldName = GetName(parameter, expression, isLeft, isSingle);
}
if (expression.Type == UtilConstants.BoolType && baseParameter.OperatorValue.IsNullOrEmpty())
{
fieldName = "( " + fieldName + "=1 )";
}
fieldName = AppendMember(parameter, isLeft, fieldName);
}
break;
case ResolveExpressType.FieldSingle:
fieldName = GetSingleName(parameter, expression, isLeft);
base.Context.Result.Append(fieldName);
break;
case ResolveExpressType.FieldMultiple:
fieldName = GetMultipleName(parameter, expression, isLeft);
base.Context.Result.Append(fieldName);
break;
case ResolveExpressType.ArrayMultiple:
case ResolveExpressType.ArraySingle:
fieldName = GetName(parameter, expression, isLeft, parameter.Context.ResolveType == ResolveExpressType.ArraySingle);
base.Context.Result.Append(fieldName);
break;
default:
break;
}
}
protected void ResolveNewExpressions(ExpressionParameter parameter, Expression item, string asName)
{
if (item is ConstantExpression)
{
this.Expression = item;
this.Start();
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new Parameter(parameterName, parameter.CommonTempData));
}
else if ((item is MemberExpression) && ((MemberExpression)item).Expression == null)
{
var paramterValue = ExpressionTool.GetPropertyValue(item as MemberExpression);
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new Parameter(parameterName, paramterValue));
}
else if ((item is MemberExpression) && ((MemberExpression)item).Expression.NodeType == ExpressionType.Constant)
{
this.Expression = item;
this.Start();
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new Parameter(parameterName, parameter.CommonTempData));
}
else if (item is MemberExpression)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
this.Context.Result.CurrentParameter = parameter;
this.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
this.Expression = item;
this.Start();
parameter.IsAppendResult();
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
this.Context.Result.CurrentParameter = null;
}
}
else if (item is UnaryExpression && ((UnaryExpression)item).Operand is MemberExpression)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
var expression = ((UnaryExpression)item).Operand as MemberExpression;
if (expression.Expression == null)
{
this.Context.Result.CurrentParameter = parameter;
this.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
this.Expression = item;
this.Start();
parameter.IsAppendResult();
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
this.Context.Result.CurrentParameter = null;
}
else if (expression.Expression is ConstantExpression)
{
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new Parameter(parameterName, ExpressionTool.GetMemberValue(expression.Member, expression)));
}
else
{
this.Context.Result.CurrentParameter = parameter;
this.Context.Result.IsLockCurrentParameter = true;
parameter.IsAppendTempDate();
this.Expression = item;
this.Start();
parameter.IsAppendResult();
this.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
this.Context.Result.CurrentParameter = null;
}
}
}
else if (item is UnaryExpression && ((UnaryExpression)item).Operand is ConstantExpression)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
this.Expression = ((UnaryExpression)item).Operand;
this.Start();
string parameterName = this.Context.SqlParameterKeyWord + "constant" + this.Context.ParameterIndex;
this.Context.ParameterIndex++;
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameterName));
this.Context.Parameters.Add(new Parameter(parameterName, parameter.CommonTempData));
}
}
else if (item is BinaryExpression)
{
if (this.Context.Result.IsLockCurrentParameter == false)
{
var newContext = this.Context.GetCopyContext();
var resolveExpressType = this.Context.IsSingle ? ResolveExpressType.WhereSingle : ResolveExpressType.WhereMultiple;
newContext.Resolve(item, resolveExpressType);
this.Context.Index = newContext.Index;
this.Context.ParameterIndex = newContext.ParameterIndex;
if (newContext.Parameters.IsValuable())
{
this.Context.Parameters.AddRange(newContext.Parameters);
}
this.Context.Result.Append(this.Context.GetAsString(asName, newContext.Result.GetString()));
this.Context.Result.CurrentParameter = null;
}
}
else if (item.Type.IsClass())
{
this.Expression = item;
this.Start();
var shortName = parameter.CommonTempData;
var listProperties = item.Type.GetProperties().Cast <PropertyInfo>().ToList();
foreach (var property in listProperties)
{
if (property.PropertyType.IsClass())
{
}
else
{
asName = this.Context.GetTranslationText(item.Type.Name + "." + property.Name);
var columnName = property.Name;
if (Context.IsJoin)
{
this.Context.Result.Append(Context.GetAsString(asName, columnName, shortName.ObjToString()));
}
else
{
this.Context.Result.Append(Context.GetAsString(asName, columnName));
}
}
}
}
else if (item is MethodCallExpression || item is UnaryExpression)
{
this.Expression = item;
this.Start();
parameter.Context.Result.Append(this.Context.GetAsString(asName, parameter.CommonTempData.ObjToString()));
}
else
{
// Check.ThrowNotSupportedException(item.GetType().Name);
}
}
/// <summary>
/// 安装下一个类型
/// </summary>
protected override void nextCreate()
{
if (!Type.Type.IsInterface)
{
LeftArray <MemberExpression> members = default(LeftArray <MemberExpression>);
nodeTypeNames.Clear();
bool isMember = true;
foreach (MemberIndex member in MemberIndex.GetMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Instance, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref members, new MemberExpression {
Attribute = attribute, Member = member, IntputParameters = member.IsField ? NullValue <ExpressionParameter> .Array : ExpressionParameter.Get(MethodParameter.Get(((PropertyInfo)member.Member).GetGetMethod(true), NullValue <Type> .Array))
});
}
}
Members = members.ToArray();
LeftArray <MethodExpression> methods = default(LeftArray <MethodExpression>);
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Instance, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref methods, new MethodExpression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
Methods = methods.ToArray();
LeftArray <StaticMemberExpression> staticMembers = default(LeftArray <StaticMemberExpression>);
foreach (MemberIndex member in MemberIndex.GetStaticMembers <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Static, true, false))
{
if (!member.IsIgnore && member.CanGet)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref staticMembers, new StaticMemberExpression {
Attribute = attribute, Member = member, IntputParameters = NullValue <ExpressionParameter> .Array
});
}
}
StaticMembers = staticMembers.ToArray();
LeftArray <StaticMethodExpression> staticMethods = default(LeftArray <StaticMethodExpression>);
foreach (MethodIndex member in MethodIndex.GetMethods <AutoCSer.Net.RemoteExpression.MemberAttribute>(Type, AutoCSer.Metadata.MemberFilters.Static, false, true, false))
{
if (!member.IsIgnore)
{
AutoCSer.Net.RemoteExpression.MemberAttribute attribute = member.GetAttribute <AutoCSer.Net.RemoteExpression.MemberAttribute>(false);
isMember &= addMember(ref staticMethods, new StaticMethodExpression {
Attribute = attribute, Method = member, IntputParameters = ExpressionParameter.Get(member.Parameters)
});
}
}
StaticMethods = staticMethods.ToArray();
if (isMember && (Members.Length | Methods.Length | StaticMemberCount) != 0)
{
create(true);
}
}
}
public BaseResolve(ExpressionParameter parameter)
{
this.Expression = parameter.CurrentExpression;
this.Context = parameter.Context;
this.BaseParameter = parameter;
}
public BaseResolve Start()
{
Context.Index++;
Expression expression = this.Expression;
ExpressionParameter parameter = new ExpressionParameter()
{
Context = this.Context,
CurrentExpression = expression,
IsLeft = this.IsLeft,
BaseExpression = this.ExactExpression,
BaseParameter = this.BaseParameter,
Index = Context.Index
};
if (expression is LambdaExpression)
{
return(new LambdaExpressionResolve(parameter));
}
else if (expression is BinaryExpression)
{
return(new BinaryExpressionResolve(parameter));
}
else if (expression is BlockExpression)
{
// Check.ThrowNotSupportedException("BlockExpression");
}
else if (expression is ConditionalExpression)
{
return(new ConditionalExpressionResolve(parameter));
}
else if (expression is MethodCallExpression)
{
return(new MethodCallExpressionResolve(parameter));
}
else if (expression is ConstantExpression)
{
return(new ConstantExpressionResolve(parameter));
}
else if (expression is MemberExpression)
{
return(new MemberExpressionResolve(parameter));
}
else if (expression is MemberInitExpression)
{
return(new MemberInitExpressionResolve(parameter));
}
else if (expression is NewExpression)
{
return(new NewExpressionResolve(parameter));
}
else if (expression is NewArrayExpression)
{
return(new NewArrayExpessionResolve(parameter));
}
else if (expression is ParameterExpression)
{
return(new TypeParameterExpressionReolve(parameter));
}
else if (expression != null && expression.NodeType.IsIn(ExpressionType.NewArrayBounds))
{
// Check.ThrowNotSupportedException("ExpressionType.NewArrayBounds");
}
return(null);
}
