/// <summary>
        /// Format generate expression
        /// </summary>
        /// <param name="generateExpression">the expression to be formatted as part of a query string</param>
        /// <returns>the expression unchanged</returns>
        protected override Expression VisitGenerate(GenerateExpression generateExpression)
        {
            var str = new GenerateVisitor().GetGenerateString(generateExpression);

            this.Builder.Append(str);
            return(generateExpression);
        }
Пример #2
0
        // protected override Expression VisitTable(TableExpression tableExpression)
        // {
        //    Builder.Append("Relatedtable(");
        //    Builder.Append(tableExpression.Name);
        //    Builder.Append(")");
        //    return tableExpression;
        // }

        /// <summary>
        /// Generate expression formatting method
        /// </summary>
        /// <param name="generateExpression">generate expression to be formatted</param>
        /// <returns>the original expression</returns>
        protected override Expression VisitGenerate(GenerateExpression generateExpression)
        {
            Builder.Append("GENERATE(\n");
            Visit(generateExpression.Source);
            Builder.Append(",\n");
            Visit(generateExpression.Generator);
            Builder.Append(")\n");
            return(generateExpression);
        }
Пример #3
0
        public List <bool> Build <T>(T item, List <ConditionModel> conditions)
        {
            var resultRules = new List <bool>();

            conditions.ForEach(rule =>
            {
                ParameterExpression genericType = Expression.Parameter(typeof(T));
                Type type = GetType <T>(genericType, rule.Key);

                if (!type.IsGenericType)
                {
                    Expression left  = Expression.Property(genericType, rule.Key);
                    Expression right = Expression.Constant(Convert.ChangeType(rule.Val, type));
                    resultRules.Add(GenerateExpression <T>(rule.Condition.ToString().GetExpressionType(), left, right, genericType)(item));
                }

                if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List <>))
                {
                    resultRules.Add(GenerateExpressionContains <T>(rule, type)(item));
                }
            });

            return(resultRules);
        }
Пример #4
0
 /// <summary>
 /// Generates query string part corresponding to a generate expression
 /// </summary>
 /// <param name="generateExpression">the input generate expression</param>
 /// <returns>query string part</returns>
 public string GetGenerateString(GenerateExpression generateExpression)
 {
     Visit(generateExpression);
     return(Builder.ToString());
 }