Example #1
0
        private LinqQueryExpression <TEntity> IsInCall <TEntity>(MethodCallExpression methodCallExpression,
                                                                 ExpressionConversionVisitor <TEntity> expressionConverter)
            where TEntity : class
        {
            var expression = expressionConverter.Visit(methodCallExpression.Arguments[1]) as LinqQueryExpression <TEntity>;
            var value      = expressionConverter.Visit(methodCallExpression.Arguments[2]) as LinqQueryExpression <TEntity>;

            if (value.QueryExpression is ValueParameterQueryExpression valueQueryExpression &&
                valueQueryExpression.Value is IEnumerable valueEnumerable)
            {
                var valueExpressions = new List <QueryExpression>();
                foreach (var o in valueEnumerable)
                {
                    valueExpressions.Add(ORMQueryExpressions.Value(o));
                }

                return(new LinqQueryExpression <TEntity>(
                           QueryExpression.IsIn(
                               expression.QueryExpression,
                               valueExpressions.ToArray()
                               ),
                           expression.JoinBuilders));
            }

            return(new LinqQueryExpression <TEntity>(
                       QueryExpression.IsIn(
                           expression.QueryExpression,
                           value.QueryExpression
                           ),
                       expression.JoinBuilders));
        }
Example #2
0
 public void Limit(int limit)
 {
     Limit(new SqlValueExpression <TEntity, int>(
               ORMQueryExpressions.Value(limit),
               new JoinBuilder <TEntity> [0]
               ));
 }
        public ExpressionResult Convert(MethodInfo methodInfo, MethodCallExpression node,
                                        ExpressionConverter expressionConverter)
        {
            var searchForExpression = expressionConverter.Convert(node.Arguments[0]);
            var searchInExpression  = expressionConverter.Convert(node.Arguments[1]);

            if (searchInExpression.QueryExpression is ValueExpression valueExpression &&
                valueExpression.Value is IEnumerable valueEnumerable)
            {
                var valueExpressions = new List <QueryExpression>();
                foreach (var value in valueEnumerable)
                {
                    valueExpressions.Add(ORMQueryExpressions.Value(value));
                }

                return(new ExpressionResult(
                           QueryExpression.Compare(searchForExpression.QueryExpression, ComparisonOperator.None,
                                                   QueryExpression.InFunction(valueExpressions.ToArray())),
                           MethodHelper.ConcatJoins(searchForExpression, searchInExpression).ToArray()
                           ));
            }

            return(new ExpressionResult(
                       QueryExpression.Compare(searchForExpression.QueryExpression, ComparisonOperator.None,
                                               QueryExpression.InFunction(searchInExpression.QueryExpression)),
                       MethodHelper.ConcatJoins(searchForExpression, searchInExpression).ToArray()
                       ));
        }
Example #4
0
 public void Offset(int offset)
 {
     Offset(new SqlValueExpression <TEntity, int>(
                ORMQueryExpressions.Value(offset),
                new JoinBuilder <TEntity> [0]
                ));
 }
            private QueryExpression GetValueExpression(object value)
            {
                if (value is QueryExpression queryExpression)
                {
                    return(queryExpression);
                }

                if (value is IQueryBuilder queryBuilder)
                {
                    return(queryBuilder.BuildQuery());
                }

                return(ORMQueryExpressions.Value(value));
            }