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); }