Esempio n. 1
0
        protected override Expression VisitCase(CaseExpression caseExpression)
        {
            var parentSearchCondition = _isSearchCondition;

            var testIsCondition = caseExpression.Operand == null;

            _isSearchCondition = false;
            var operand     = (SqlExpression)Visit(caseExpression.Operand);
            var whenClauses = new List <CaseWhenClause>();

            foreach (var whenClause in caseExpression.WhenClauses)
            {
                _isSearchCondition = testIsCondition;
                var test = (SqlExpression)Visit(whenClause.Test);
                _isSearchCondition = false;
                var result = (SqlExpression)Visit(whenClause.Result);
                whenClauses.Add(new CaseWhenClause(test, result));
            }

            _isSearchCondition = false;
            var elseResult = (SqlExpression)Visit(caseExpression.ElseResult);

            _isSearchCondition = parentSearchCondition;

            return(ApplyConversion(caseExpression.Update(operand, whenClauses, elseResult), condition: false));
        }
Esempio n. 2
0
        protected override Expression VisitCase(CaseExpression caseExpression)
        {
            Check.NotNull(caseExpression, nameof(caseExpression));

            _isNullable = false;
            // if there is no 'else' there is a possibility of null, when none of the conditions are met
            // otherwise the result is nullable if any of the WhenClause results OR ElseResult is nullable
            var isNullable = caseExpression.ElseResult == null;

            var canOptimize     = _canOptimize;
            var testIsCondition = caseExpression.Operand == null;

            _canOptimize = false;
            var newOperand     = (SqlExpression)Visit(caseExpression.Operand);
            var newWhenClauses = new List <CaseWhenClause>();

            foreach (var whenClause in caseExpression.WhenClauses)
            {
                _canOptimize = testIsCondition;
                var newTest = (SqlExpression)Visit(whenClause.Test);
                _canOptimize = false;
                _isNullable  = false;
                var newResult = (SqlExpression)Visit(whenClause.Result);
                isNullable |= _isNullable;
                newWhenClauses.Add(new CaseWhenClause(newTest, newResult));
            }

            _canOptimize = false;
            var newElseResult = (SqlExpression)Visit(caseExpression.ElseResult);

            _isNullable |= isNullable;
            _canOptimize = canOptimize;

            return(caseExpression.Update(newOperand, newWhenClauses, newElseResult));
        }
Esempio n. 3
0
        protected override Expression VisitCase(CaseExpression caseExpression)
        {
            Check.NotNull(caseExpression, nameof(caseExpression));

            var parentOptimize = _optimize;

            var testIsCondition = caseExpression.Operand == null;

            _optimize = false;
            var operand     = (SqlExpression)Visit(caseExpression.Operand);
            var whenClauses = new List <CaseWhenClause>();

            foreach (var whenClause in caseExpression.WhenClauses)
            {
                _optimize = testIsCondition;
                var test = (SqlExpression)Visit(whenClause.Test);
                _optimize = false;
                var result = (SqlExpression)Visit(whenClause.Result);
                whenClauses.Add(new CaseWhenClause(test, result));
            }

            _optimize = false;
            var elseResult = (SqlExpression)Visit(caseExpression.ElseResult);

            _optimize = parentOptimize;

            return(ApplyConversion(caseExpression.Update(operand, whenClauses, elseResult), condition: false));
        }
        private SqlExpression ApplyTypeMappingOnCase(
            CaseExpression caseExpression, RelationalTypeMapping typeMapping)
        {
            var whenClauses = new List<CaseWhenClause>();
            foreach (var caseWhenClause in caseExpression.WhenClauses)
            {
                whenClauses.Add(
                    new CaseWhenClause(
                        caseWhenClause.Test,
                        ApplyTypeMapping(caseWhenClause.Result, typeMapping)));
            }

            var elseResult = ApplyTypeMapping(caseExpression.ElseResult, typeMapping);

            return caseExpression.Update(caseExpression.Operand, whenClauses, elseResult);
        }
        private CaseExpression VisitCaseExpression(CaseExpression caseExpression)
        {
            // if there is no 'else' there is a possibility of null, when none of the conditions are met
            // otherwise the result is nullable if any of the WhenClause results OR ElseResult is nullable
            var isNullable = caseExpression.ElseResult == null;

            var newOperand     = (SqlExpression)Visit(caseExpression.Operand);
            var newWhenClauses = new List <CaseWhenClause>();

            foreach (var whenClause in caseExpression.WhenClauses)
            {
                var newTest   = (SqlExpression)Visit(whenClause.Test);
                var newResult = (SqlExpression)Visit(whenClause.Result);
                isNullable |= _isNullable;
                newWhenClauses.Add(new CaseWhenClause(newTest, newResult));
            }

            var newElseResult = (SqlExpression)Visit(caseExpression.ElseResult);

            _isNullable |= isNullable;

            return(caseExpression.Update(newOperand, newWhenClauses, newElseResult));
        }
 protected override Expression VisitCase(CaseExpression x)
 {
     return(x?.Update(x.Operand.VisitNode(this), x.WhenClauses.ToList(), x.ElseResult.VisitNode(this)));
 }