Example #1
0
        /// <summary>
        /// Parse expression
        /// </summary>
        /// <param name="parameter"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        private Expression ParseWhereExpression(ParameterExpression parameter,
                                                SqlSelectParser.ExprContext context)
        {
            if (context.NOT() != null)
            {
                return(Expression.Not(
                           ParseWhereExpression(parameter, context.expr(0))));
            }
            if (context.AND() != null)
            {
                return(Expression.And(
                           ParseWhereExpression(parameter, context.expr(0)),
                           ParseWhereExpression(parameter, context.expr(1))));
            }
            if (context.OR() != null)
            {
                return(Expression.Or(
                           ParseWhereExpression(parameter, context.expr(0)),
                           ParseWhereExpression(parameter, context.expr(1))));
            }

            if (context.scalarFunction() != null)
            {
                return(ParseScalarFunction(parameter, context));
            }

            if (context.BR_OPEN() != null)
            {
                return(ParseWhereExpression(parameter, context.expr(0)));
            }
            return(ParseComparisonExpression(parameter, context));
        }
Example #2
0
        /// <summary>
        /// Parse scalar function
        /// </summary>
        /// <param name="parameter"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        private Expression ParseScalarFunction(ParameterExpression parameter,
                                               SqlSelectParser.ExprContext context)
        {
            var scalarFunctionContext = context.scalarFunction();

            var expr = scalarFunctionContext.scalarTypeFunction() != null?
                       ParseScalarLambda(scalarFunctionContext.scalarTypeFunction()) :
                           ParseScalarLambda(scalarFunctionContext);

            var lhs = Expression.Invoke(expr,
                                        ParseParameterBinding(parameter, scalarFunctionContext.columnName()));
            var rhs = Expression.Constant(context.literal_value() != null ?
                                          ParseLiteralValue(context.literal_value()) : _serializer.FromObject(true));

            return(CreateBinaryExpression(context.COMPARISON_OPERATOR()?.GetText() ?? "=",
                                          lhs, rhs));
        }
Example #3
0
        /// <summary>
        /// Parse comparison expression
        /// </summary>
        /// <param name="parameter"></param>
        /// <param name="context"></param>
        /// <returns></returns>
        private Expression ParseComparisonExpression(ParameterExpression parameter,
                                                     SqlSelectParser.ExprContext context)
        {
            var        lhs = ParseParameterBinding(parameter, context.columnName(0));
            Expression rhs;

            if (context.columnName().Length > 1)
            {
                rhs = ParseParameterBinding(parameter, context.columnName(1));
            }
            else if (context.array_literal() != null)
            {
                rhs = Expression.Constant(context.array_literal().literal_value()
                                          .Select(ParseLiteralValue)
                                          .ToArray());
            }
            else
            {
                rhs = Expression.Constant(ParseLiteralValue(context.literal_value()));
            }
            return(CreateBinaryExpression(context.COMPARISON_OPERATOR().GetText(), lhs, rhs));
        }