/// <summary>
        ///     This API supports the Entity Framework Core infrastructure and is not intended to be used 
        ///     directly from your code. This API may change or be removed in future releases.
        /// </summary>
        public virtual void AddParameter(string invariantName, string name, RelationalTypeMapping typeMapping, bool nullable)
        {
            Check.NotEmpty(invariantName, nameof(invariantName));
            Check.NotEmpty(name, nameof(name));
            Check.NotNull(typeMapping, nameof(typeMapping));

            _parameters.Add(
                new TypeMappedRelationalParameter(
                    invariantName,
                    name,
                    typeMapping,
                    nullable));
        }
        public void CreateParameter_creates_parameter_with_original_values()
        {
            var parameterMock = new Mock<DbParameter>();
            var commandMock = new Mock<DbCommand>();
            commandMock
                .Protected()
                .Setup<DbParameter>("CreateDbParameter")
                .Returns(parameterMock.Object);

            var columnModificationMock = new Mock<ColumnModification>();
            columnModificationMock.Setup(m => m.Property).Returns(new Mock<IProperty>().Object);
            columnModificationMock.Setup(m => m.OriginalParameterName).Returns("op");

            var parameter = new RelationalTypeMapping("s", DbType.String).CreateParameter(commandMock.Object, columnModificationMock.Object, useOriginalValue: true);

            Assert.Same(parameterMock.Object, parameter);
            columnModificationMock.Verify(m => m.Value, Times.Never);
            columnModificationMock.Verify(m => m.OriginalValue, Times.Once);
        }
 public NpgsqlJsonPocoTranslator(NpgsqlSqlExpressionFactory sqlExpressionFactory)
 {
     _sqlExpressionFactory = sqlExpressionFactory;
     _stringTypeMapping    = sqlExpressionFactory.FindMapping(typeof(string));
 }
            private static Expression CreateGetValueExpression(
                int index,
                bool nullable,
                RelationalTypeMapping typeMapping,
                Type clrType)
            {
                var getMethod = typeMapping.GetDataReaderMethod();

                var indexExpression = Expression.Constant(index);

                Expression valueExpression
                    = Expression.Call(
                          getMethod.DeclaringType != typeof(DbDataReader)
                            ? Expression.Convert(DataReaderParameter, getMethod.DeclaringType)
                            : (Expression)DataReaderParameter,
                          getMethod,
                          indexExpression);

                valueExpression = typeMapping.CustomizeDataReaderExpression(valueExpression);

                var converter = typeMapping.Converter;

                if (converter != null)
                {
                    if (valueExpression.Type != converter.ProviderClrType)
                    {
                        valueExpression = Expression.Convert(valueExpression, converter.ProviderClrType);
                    }

                    valueExpression = ReplacingExpressionVisitor.Replace(
                        converter.ConvertFromProviderExpression.Parameters.Single(),
                        valueExpression,
                        converter.ConvertFromProviderExpression.Body);
                }

                if (valueExpression.Type != clrType)
                {
                    valueExpression = Expression.Convert(valueExpression, clrType);
                }

                //var exceptionParameter
                //    = Expression.Parameter(typeof(Exception), name: "e");

                //var property = materializationInfo.Property;

                //if (detailedErrorsEnabled)
                //{
                //    var catchBlock
                //        = Expression
                //            .Catch(
                //                exceptionParameter,
                //                Expression.Call(
                //                    _throwReadValueExceptionMethod
                //                        .MakeGenericMethod(valueExpression.Type),
                //                    exceptionParameter,
                //                    Expression.Call(
                //                        dataReaderExpression,
                //                        _getFieldValueMethod.MakeGenericMethod(typeof(object)),
                //                        indexExpression),
                //                    Expression.Constant(property, typeof(IPropertyBase))));

                //    valueExpression = Expression.TryCatch(valueExpression, catchBlock);
                //}

                //if (box && valueExpression.Type.GetTypeInfo().IsValueType)
                //{
                //    valueExpression = Expression.Convert(valueExpression, typeof(object));
                //}

                if (nullable)
                {
                    valueExpression
                        = Expression.Condition(
                              Expression.Call(DataReaderParameter, _isDbNullMethod, indexExpression),
                              Expression.Default(valueExpression.Type),
                              valueExpression);
                }

                return(valueExpression);
            }
Example #5
0
            public override Expression Visit(Expression expression)
            {
                if (expression is InExpression inExpression &&
                    inExpression.Values != null)
                {
                    var inValues     = new List <object>();
                    var hasNullValue = false;
                    RelationalTypeMapping typeMapping = null;

                    switch (inExpression.Values)
                    {
                    case SqlConstantExpression sqlConstant:
                    {
                        typeMapping = sqlConstant.TypeMapping;
                        var values = (IEnumerable)sqlConstant.Value;
                        foreach (var value in values)
                        {
                            if (value == null)
                            {
                                hasNullValue = true;
                                continue;
                            }

                            inValues.Add(value);
                        }

                        break;
                    }

                    case SqlParameterExpression sqlParameter:
                    {
                        typeMapping = sqlParameter.TypeMapping;
                        var values = (IEnumerable)_parametersValues[sqlParameter.Name];
                        foreach (var value in values)
                        {
                            if (value == null)
                            {
                                hasNullValue = true;
                                continue;
                            }

                            inValues.Add(value);
                        }

                        break;
                    }
                    }

                    var updatedInExpression = inValues.Count > 0
                        ? _sqlExpressionFactory.In(
                        (SqlExpression)Visit(inExpression.Item),
                        _sqlExpressionFactory.Constant(inValues, typeMapping),
                        inExpression.IsNegated)
                        : null;

                    var nullCheckExpression = hasNullValue
                        ? inExpression.IsNegated
                            ? _sqlExpressionFactory.IsNotNull(inExpression.Item)
                            : _sqlExpressionFactory.IsNull(inExpression.Item)
                        : null;

                    if (updatedInExpression != null &&
                        nullCheckExpression != null)
                    {
                        return(inExpression.IsNegated
                            ? _sqlExpressionFactory.AndAlso(updatedInExpression, nullCheckExpression)
                            : _sqlExpressionFactory.OrElse(updatedInExpression, nullCheckExpression));
                    }

                    if (updatedInExpression == null &&
                        nullCheckExpression == null)
                    {
                        return(_sqlExpressionFactory.Equal(
                                   _sqlExpressionFactory.Constant(true), _sqlExpressionFactory.Constant(inExpression.IsNegated)));
                    }

                    return((SqlExpression)updatedInExpression ?? nullCheckExpression);
                }

                return(base.Visit(expression));
            }
Example #6
0
 public override SqlExpression ApplyTypeMapping(SqlExpression sqlExpression, RelationalTypeMapping typeMapping)
 => sqlExpression == null || sqlExpression.TypeMapping != null
                         ? sqlExpression
                         : sqlExpression switch
 {
 internal SqlParameterExpression(ParameterExpression parameterExpression, RelationalTypeMapping typeMapping)
     : base(parameterExpression.Type, typeMapping)
 {
     _parameterExpression = parameterExpression;
 }
 public virtual MySqlJsonTraversalExpression Clone(bool returnsText, Type type, RelationalTypeMapping typeMapping)
 => new MySqlJsonTraversalExpression(Expression, Path, returnsText, type, typeMapping);
 public override SqlFunctionExpression ApplyTypeMapping(RelationalTypeMapping typeMapping)
 {
     return(new FbSpacedFunctionExpression(Name, Arguments, IsNullable, ArgumentsPropagateNullability, Type, typeMapping ?? TypeMapping));
 }
 private NpgsqlArrayArrayTypeMapping(string storeType, RelationalTypeMapping elementMapping, Type arrayType)
     : this(CreateParameters(storeType, elementMapping, arrayType), elementMapping)
 {
 }
 protected abstract RelationalTypeMapping Clone(RelationalTypeMappingParameters parameters, RelationalTypeMapping elementMapping);
Example #12
0
 /// <inheritdoc />
 bool IConventionDbFunctionParameterBuilder.CanSetTypeMapping(RelationalTypeMapping typeMapping, bool fromDataAnnotation)
 => Overrides(fromDataAnnotation, _parameter.GetTypeMappingConfigurationSource()) ||
 _parameter.TypeMapping == typeMapping;
Example #13
0
 /// <summary>
 ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
 ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
 ///     any release. You should only use it directly in your code with extreme caution and knowing that
 ///     doing so can result in application failures when updating to a new Entity Framework Core release.
 /// </summary>
 public override void AddDbParameter(DbCommand command, object?value)
 => command.Parameters
 .Add(
     RelationalTypeMapping
     .CreateParameter(command, Name, value, IsNullable));
Example #14
0
            private Expression CreateGetValueExpression(
                ParameterExpression dbDataReader,
                int index,
                bool nullable,
                RelationalTypeMapping typeMapping,
                Type clrType)
            {
                var getMethod = typeMapping.GetDataReaderMethod();

                Expression indexExpression = Expression.Constant(index);

                if (_indexMapParameter != null)
                {
                    indexExpression = Expression.ArrayIndex(_indexMapParameter, indexExpression);
                }

                Expression valueExpression
                    = Expression.Call(
                          getMethod.DeclaringType != typeof(DbDataReader)
                            ? Expression.Convert(dbDataReader, getMethod.DeclaringType)
                            : (Expression)dbDataReader,
                          getMethod,
                          indexExpression);

                if (ProjectionColumns != null)
                {
                    var columnType = valueExpression.Type;
                    if (!columnType.IsValueType ||
                        !BufferedDataReader.IsSupportedValueType(columnType))
                    {
                        columnType      = typeof(object);
                        valueExpression = Expression.Convert(valueExpression, typeof(object));
                    }

                    if (ProjectionColumns[index] == null)
                    {
                        ProjectionColumns[index] = ReaderColumn.Create(
                            columnType,
                            nullable,
                            _indexMapParameter != null ? ((ColumnExpression)_selectExpression.Projection[index].Expression).Name : null,
                            Expression.Lambda(
                                valueExpression,
                                dbDataReader,
                                _indexMapParameter ?? Expression.Parameter(typeof(int[]))).Compile());
                    }

                    if (getMethod.DeclaringType != typeof(DbDataReader))
                    {
                        valueExpression
                            = Expression.Call(
                                  dbDataReader,
                                  RelationalTypeMapping.GetDataReaderMethod(columnType),
                                  indexExpression);
                    }
                }

                valueExpression = typeMapping.CustomizeDataReaderExpression(valueExpression);

                var converter = typeMapping.Converter;

                if (converter != null)
                {
                    if (valueExpression.Type != converter.ProviderClrType)
                    {
                        valueExpression = Expression.Convert(valueExpression, converter.ProviderClrType);
                    }

                    valueExpression = ReplacingExpressionVisitor.Replace(
                        converter.ConvertFromProviderExpression.Parameters.Single(),
                        valueExpression,
                        converter.ConvertFromProviderExpression.Body);
                }

                if (valueExpression.Type != clrType)
                {
                    valueExpression = Expression.Convert(valueExpression, clrType);
                }

                //var exceptionParameter
                //    = Expression.Parameter(typeof(Exception), name: "e");

                //var property = materializationInfo.Property;

                //if (detailedErrorsEnabled)
                //{
                //    var catchBlock
                //        = Expression
                //            .Catch(
                //                exceptionParameter,
                //                Expression.Call(
                //                    _throwReadValueExceptionMethod
                //                        .MakeGenericMethod(valueExpression.Type),
                //                    exceptionParameter,
                //                    Expression.Call(
                //                        dataReaderExpression,
                //                        _getFieldValueMethod.MakeGenericMethod(typeof(object)),
                //                        indexExpression),
                //                    Expression.Constant(property, typeof(IPropertyBase))));

                //    valueExpression = Expression.TryCatch(valueExpression, catchBlock);
                //}

                //if (box && valueExpression.Type.GetTypeInfo().IsValueType)
                //{
                //    valueExpression = Expression.Convert(valueExpression, typeof(object));
                //}

                if (nullable)
                {
                    valueExpression
                        = Expression.Condition(
                              Expression.Call(dbDataReader, _isDbNullMethod, indexExpression),
                              Expression.Default(valueExpression.Type),
                              valueExpression);
                }

                return(valueExpression);
            }
        private SqlExpression SimplifyBinaryExpression(
            ExpressionType operatorType,
            SqlExpression left,
            SqlExpression right,
            RelationalTypeMapping typeMapping)
        {
            switch (operatorType)
            {
            case ExpressionType.AndAlso:
            case ExpressionType.OrElse:
                var leftUnary  = left as SqlUnaryExpression;
                var rightUnary = right as SqlUnaryExpression;
                if (leftUnary != null &&
                    rightUnary != null &&
                    (leftUnary.OperatorType == ExpressionType.Equal || leftUnary.OperatorType == ExpressionType.NotEqual) &&
                    (rightUnary.OperatorType == ExpressionType.Equal || rightUnary.OperatorType == ExpressionType.NotEqual) &&
                    leftUnary.Operand.Equals(rightUnary.Operand))
                {
                    // a is null || a is null -> a is null
                    // a is not null || a is not null -> a is not null
                    // a is null && a is null -> a is null
                    // a is not null && a is not null -> a is not null
                    // a is null || a is not null -> true
                    // a is null && a is not null -> false
                    return(leftUnary.OperatorType == rightUnary.OperatorType
                            ? (SqlExpression)leftUnary
                            : _sqlExpressionFactory.Constant(operatorType == ExpressionType.OrElse, typeMapping));
                }

                return(SimplifyLogicalSqlBinaryExpression(
                           operatorType,
                           left,
                           right,
                           typeMapping));

            case ExpressionType.Equal:
            case ExpressionType.NotEqual:
                var leftConstant      = left as SqlConstantExpression;
                var rightConstant     = right as SqlConstantExpression;
                var leftNullConstant  = leftConstant != null && leftConstant.Value == null;
                var rightNullConstant = rightConstant != null && rightConstant.Value == null;
                if (leftNullConstant || rightNullConstant)
                {
                    return(SimplifyNullComparisonExpression(
                               operatorType,
                               left,
                               right,
                               leftNullConstant,
                               rightNullConstant,
                               typeMapping));
                }

                var leftBoolValue  = left.Type == typeof(bool) ? (bool?)leftConstant?.Value : null;
                var rightBoolValue = right.Type == typeof(bool) ? (bool?)rightConstant?.Value : null;
                if (leftBoolValue != null || rightBoolValue != null)
                {
                    return(SimplifyBoolConstantComparisonExpression(
                               operatorType,
                               left,
                               right,
                               leftBoolValue,
                               rightBoolValue,
                               typeMapping));
                }

                // only works when a is not nullable
                // a == a -> true
                // a != a -> false
                if ((left is LikeExpression ||
                     left is ColumnExpression columnExpression && !columnExpression.IsNullable) &&
                    left.Equals(right))
                {
                    return(_sqlExpressionFactory.Constant(operatorType == ExpressionType.Equal, typeMapping));
                }

                break;
            }

            return(_sqlExpressionFactory.MakeBinary(operatorType, left, right, typeMapping) !);
        }
Example #16
0
        private SqlExpression SimplifyNullNotNullExpression(
            ExpressionType operatorType,
            SqlExpression operand,
            Type type,
            RelationalTypeMapping typeMapping)
        {
            switch (operatorType)
            {
            case ExpressionType.Equal:
            case ExpressionType.NotEqual:
                switch (operand)
                {
                case SqlConstantExpression constantOperand:
                    return(SqlExpressionFactory.Constant(
                               operatorType == ExpressionType.Equal
                                    ? constantOperand.Value == null
                                    : constantOperand.Value != null,
                               typeMapping));

                case ColumnExpression columnOperand
                    when !columnOperand.IsNullable:
                    return(SqlExpressionFactory.Constant(operatorType == ExpressionType.NotEqual, typeMapping));

                case SqlUnaryExpression sqlUnaryOperand:
                    if (sqlUnaryOperand.OperatorType == ExpressionType.Convert ||
                        sqlUnaryOperand.OperatorType == ExpressionType.Not ||
                        sqlUnaryOperand.OperatorType == ExpressionType.Negate)
                    {
                        // op(a) is null -> a is null
                        // op(a) is not null -> a is not null
                        return(SimplifyNullNotNullExpression(operatorType, sqlUnaryOperand.Operand, type, typeMapping));
                    }

                    if (sqlUnaryOperand.OperatorType == ExpressionType.Equal ||
                        sqlUnaryOperand.OperatorType == ExpressionType.NotEqual)
                    {
                        // (a is null) is null -> false
                        // (a is not null) is null -> false
                        // (a is null) is not null -> true
                        // (a is not null) is not null -> true
                        return(SqlExpressionFactory.Constant(operatorType == ExpressionType.NotEqual, typeMapping));
                    }
                    break;

                case SqlBinaryExpression sqlBinaryOperand:
                    // in general:
                    // binaryOp(a, b) == null -> a == null || b == null
                    // binaryOp(a, b) != null -> a != null && b != null
                    // for AndAlso, OrElse we can't do this optimization
                    // we could do something like this, but it seems too complicated:
                    // (a && b) == null -> a == null && b != 0 || a != 0 && b == null
                    if (sqlBinaryOperand.OperatorType != ExpressionType.AndAlso &&
                        sqlBinaryOperand.OperatorType != ExpressionType.OrElse)
                    {
                        var newLeft  = SimplifyNullNotNullExpression(operatorType, sqlBinaryOperand.Left, typeof(bool), typeMapping);
                        var newRight = SimplifyNullNotNullExpression(operatorType, sqlBinaryOperand.Right, typeof(bool), typeMapping);

                        return(SimplifyLogicalSqlBinaryExpression(
                                   operatorType == ExpressionType.Equal
                                            ? ExpressionType.OrElse
                                            : ExpressionType.AndAlso,
                                   newLeft,
                                   newRight,
                                   typeMapping));
                    }
                    break;

                case SqlFunctionExpression sqlFunctionExpression
                    when sqlFunctionExpression.IsBuiltIn &&
                    string.Equals("COALESCE", sqlFunctionExpression.Name, StringComparison.OrdinalIgnoreCase):
                    // for coalesce:
                    // (a ?? b) == null -> a == null && b == null
                    // (a ?? b) != null -> a != null || b != null
                    var leftArgument = SimplifyNullNotNullExpression(
                        operatorType, sqlFunctionExpression.Arguments[0], typeof(bool), typeMapping);
                    var rightArgument = SimplifyNullNotNullExpression(
                        operatorType, sqlFunctionExpression.Arguments[1], typeof(bool), typeMapping);

                    return(SimplifyLogicalSqlBinaryExpression(
                               operatorType == ExpressionType.Equal
                                    ? ExpressionType.AndAlso
                                    : ExpressionType.OrElse,
                               leftArgument,
                               rightArgument,
                               typeMapping));
                }
                break;
            }

            return(SqlExpressionFactory.MakeUnary(operatorType, operand, type, typeMapping));
        }
 /// <summary>
 ///     This API supports the Entity Framework Core infrastructure and is not intended to be used
 ///     directly from your code. This API may change or be removed in future releases.
 /// </summary>
 protected override void GenerateLiteralValue(StringBuilder builder, string value, RelationalTypeMapping typeMapping = null)
 {
     builder.Append(typeMapping.IsUnicode ? "N'" : "'");
     EscapeLiteral(builder, value);
     builder.Append("'");
 }
Example #18
0
 public SingleDimComparerWithComparer(RelationalTypeMapping elementMapping) : base(
         (a, b) => Compare(a, b, (ValueComparer <TElem>)elementMapping.Comparer),
         o => o.GetHashCode(), // TODO: Need to get hash code of elements...
         source => Snapshot(source, (ValueComparer <TElem>)elementMapping.Comparer))
 {
 }
Example #19
0
 private static RelationalTypeMapping FilterByClrType(RelationalTypeMapping mapping, RelationalTypeMappingInfo mappingInfo)
 => mapping != null &&
 (mappingInfo.ClrType == null ||
  mappingInfo.ClrType == mapping.ClrType)
         ? mapping
         : null;
Example #20
0
 /// <summary>
 /// Creates the default array mapping (i.e. for the single-dimensional CLR array type)
 /// </summary>
 public NpgsqlArrayTypeMapping(string storeType, RelationalTypeMapping elementMapping)
     : this(storeType, elementMapping, elementMapping.ClrType.MakeArrayType())
 {
 }
        public virtual MySqlJsonTraversalExpression Append([NotNull] SqlExpression pathComponent, Type returnType, RelationalTypeMapping typeMapping)
        {
            var newPath = new SqlExpression[Path.Count + 1];

            for (var i = 0; i < Path.Count; i++)
            {
                newPath[i] = Path[i];
            }
            newPath[newPath.Length - 1] = pathComponent;
            return(new MySqlJsonTraversalExpression(Expression, newPath, ReturnsText, returnType, typeMapping));
        }
Example #22
0
 /// <summary>
 /// Creates the default array mapping (i.e. for the single-dimensional CLR array type)
 /// </summary>
 public NpgsqlArrayTypeMapping(RelationalTypeMapping elementMapping, Type arrayType)
     : this(elementMapping.StoreType + "[]", elementMapping, arrayType)
 {
 }
 public SqlExpression ApplyTypeMapping(RelationalTypeMapping typeMapping)
 => new SqlParameterExpression(_parameterExpression, typeMapping);
Example #24
0
 NpgsqlArrayTypeMapping(string storeType, RelationalTypeMapping elementMapping, Type arrayType)
     : this(new RelationalTypeMappingParameters(
                new CoreTypeMappingParameters(arrayType, null, CreateComparer(elementMapping, arrayType)), storeType
                ), elementMapping)
 {
 }
Example #25
0
 public MySqlSqlExpressionFactory(SqlExpressionFactoryDependencies dependencies)
     : base(dependencies)
 {
     _typeMappingSource = dependencies.TypeMappingSource;
     _boolTypeMapping   = _typeMappingSource.FindMapping(typeof(bool));
 }
Example #26
0
 protected NpgsqlArrayTypeMapping(RelationalTypeMappingParameters parameters, RelationalTypeMapping elementMapping)
     : base(parameters)
     => ElementMapping = elementMapping;
 public FbExtractExpression(string part, SqlExpression valueExpression, RelationalTypeMapping typeMapping)
     : base("EXTRACT", Array.Empty <SqlExpression>(), true, Array.Empty <bool>(), typeof(int), typeMapping)
 {
     Part            = part;
     ValueExpression = valueExpression;
 }
 public static SqlFunctionExpression CreateNiladic(
     SqlExpression instance,
     string name,
     Type type,
     RelationalTypeMapping typeMapping)
 => new SqlFunctionExpression(instance, schema: null, name, niladic: true, arguments: null, builtIn: true, type, typeMapping);
Example #29
0
 public LikeExpression(SqlExpression match, SqlExpression pattern, SqlExpression escapeChar, RelationalTypeMapping typeMapping)
     : base(typeof(bool), typeMapping)
 {
     Match      = match;
     Pattern    = pattern;
     EscapeChar = escapeChar;
 }
 public static SqlFunctionExpression Create(
     string name,
     IEnumerable <SqlExpression> arguments,
     Type type,
     RelationalTypeMapping typeMapping)
 => new SqlFunctionExpression(instance: null, schema: null, name, niladic: false, arguments, builtIn: true, type, typeMapping);
Example #31
0
        private SqlExpression SimplifyUnaryExpression(
            ExpressionType operatorType,
            SqlExpression operand,
            Type type,
            RelationalTypeMapping typeMapping)
        {
            switch (operatorType)
            {
            case ExpressionType.Not
                when type == typeof(bool) ||
                type == typeof(bool?):
            {
                switch (operand)
                {
                // !(true) -> false
                // !(false) -> true
                case SqlConstantExpression constantOperand
                    when constantOperand.Value is bool value:
                {
                    return(SqlExpressionFactory.Constant(!value, typeMapping));
                }

                case InExpression inOperand:
                    return(inOperand.Negate());

                case SqlUnaryExpression unaryOperand:
                    switch (unaryOperand.OperatorType)
                    {
                    // !(!a) -> a
                    case ExpressionType.Not:
                        return(unaryOperand.Operand);

                    //!(a IS NULL) -> a IS NOT NULL
                    case ExpressionType.Equal:
                        return(SqlExpressionFactory.IsNotNull(unaryOperand.Operand));

                    //!(a IS NOT NULL) -> a IS NULL
                    case ExpressionType.NotEqual:
                        return(SqlExpressionFactory.IsNull(unaryOperand.Operand));
                    }

                    break;

                case SqlBinaryExpression binaryOperand:
                {
                    // De Morgan's
                    if (binaryOperand.OperatorType == ExpressionType.AndAlso ||
                        binaryOperand.OperatorType == ExpressionType.OrElse)
                    {
                        var newLeft  = SimplifyUnaryExpression(ExpressionType.Not, binaryOperand.Left, type, typeMapping);
                        var newRight = SimplifyUnaryExpression(ExpressionType.Not, binaryOperand.Right, type, typeMapping);

                        return(SimplifyLogicalSqlBinaryExpression(
                                   binaryOperand.OperatorType == ExpressionType.AndAlso
                                        ? ExpressionType.OrElse
                                        : ExpressionType.AndAlso,
                                   newLeft,
                                   newRight,
                                   binaryOperand.TypeMapping));
                    }

                    // those optimizations are only valid in 2-value logic
                    // they are safe to do here because if we apply null semantics
                    // because null semantics removes possibility of nulls in the tree when the comparison is wrapped around NOT
                    if (!_useRelationalNulls &&
                        TryNegate(binaryOperand.OperatorType, out var negated))
                    {
                        return(SimplifyBinaryExpression(
                                   negated,
                                   binaryOperand.Left,
                                   binaryOperand.Right,
                                   binaryOperand.TypeMapping));
                    }
                }
                break;
                }
                break;
            }

            case ExpressionType.Equal:
            case ExpressionType.NotEqual:
                return(SimplifyNullNotNullExpression(
                           operatorType,
                           operand,
                           type,
                           typeMapping));
            }

            return(SqlExpressionFactory.MakeUnary(operatorType, operand, type, typeMapping));
        }
Example #32
0
        public RowNumberExpression(
            IReadOnlyList <SqlExpression> partitions, IReadOnlyList <OrderingExpression> orderings, RelationalTypeMapping typeMapping)
            : base(typeof(long), typeMapping)
        {
            Check.NotEmpty(orderings, nameof(orderings));

            Partitions = partitions;
            Orderings  = orderings;
        }
 public FbSpacedFunctionExpression(string name, IEnumerable <SqlExpression> arguments, bool nullable, IEnumerable <bool> argumentsPropagateNullability, Type type, RelationalTypeMapping typeMapping)
     : base(name, arguments, nullable, argumentsPropagateNullability, type, typeMapping)
 {
 }
 /// <summary>
 ///     This API supports the Entity Framework Core infrastructure and is not intended to be used
 ///     directly from your code. This API may change or be removed in future releases.
 /// </summary>
 protected override string GenerateLiteralValue(string value, RelationalTypeMapping typeMapping = null)
     => typeMapping == null || typeMapping.IsUnicode
         ? $"N'{EscapeLiteral(Check.NotNull(value, nameof(value)))}'"
         : $"'{EscapeLiteral(Check.NotNull(value, nameof(value)))}'";