From 8e080f180bc3c3b9f81bd1342a41e5923415faa0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Efe=20=C4=B0nal?= <87021466+efeesrefinal@users.noreply.github.com> Date: Thu, 19 Nov 2026 06:57:00 +0300 Subject: [PATCH] Keep a space char in string.Join, PadLeft/PadRight and char.ToString(), match Convert.ToString(bool) and a null string.Join separator Fixes #4096 --- .../Internal/NpgsqlConvertTranslator.cs | 11 ++++ .../NpgsqlObjectToStringTranslator.cs | 9 +++ .../Internal/NpgsqlStringMethodTranslator.cs | 14 ++++- .../Query/ArrayArrayQueryTest.cs | 51 +++++++++++++++++ .../Query/CharacterQueryNpgsqlTest.cs | 55 +++++++++++++++++++ .../MiscellaneousTranslationsNpgsqlTest.cs | 17 ++++++ 6 files changed, 154 insertions(+), 3 deletions(-) diff --git a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlConvertTranslator.cs b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlConvertTranslator.cs index 3c7d22e6da..a8d8691f42 100644 --- a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlConvertTranslator.cs +++ b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlConvertTranslator.cs @@ -33,6 +33,17 @@ or nameof(Convert.ToDouble) or nameof(Convert.ToInt16) or nameof(Convert.ToInt32 return null; } + // Casting a boolean to text yields true/false, whereas Convert.ToString(bool) returns True/False. + if (method.Name is nameof(Convert.ToString) && convertArg.Type == typeof(bool)) + { + return sqlExpressionFactory.Case( + [ + new CaseWhenClause(convertArg, sqlExpressionFactory.Constant(bool.TrueString)), + new CaseWhenClause(sqlExpressionFactory.Not(convertArg), sqlExpressionFactory.Constant(bool.FalseString)) + ], + elseResult: null); + } + return sqlExpressionFactory.Convert(convertArg, method.ReturnType); } diff --git a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlObjectToStringTranslator.cs b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlObjectToStringTranslator.cs index e621199d0a..63998bcb75 100644 --- a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlObjectToStringTranslator.cs +++ b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlObjectToStringTranslator.cs @@ -99,6 +99,15 @@ public NpgsqlObjectToStringTranslator(IRelationalTypeMappingSource typeMappingSo } } + // Converting character(1) to text strips spaces; pad back to one character. + if (instance.Type == typeof(char) + && instance.TypeMapping is NpgsqlCharacterCharTypeMapping { StoreTypeNameBase: "character" or "char" }) + { + return _sqlExpressionFactory.Coalesce( + NpgsqlStringMethodTranslator.TranslateCharArgument(instance, _sqlExpressionFactory), + _sqlExpressionFactory.Constant(string.Empty)); + } + return _typeMapping.Contains(instance.Type) || instance.Type.UnwrapNullableType().IsEnum && instance.TypeMapping is NpgsqlEnumTypeMapping ? _sqlExpressionFactory.Coalesce( diff --git a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlStringMethodTranslator.cs b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlStringMethodTranslator.cs index f7abee90d0..46e861737e 100644 --- a/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlStringMethodTranslator.cs +++ b/src/EFCore.PG/Query/ExpressionTranslators/Internal/NpgsqlStringMethodTranslator.cs @@ -219,7 +219,7 @@ arguments is [var startIndex] var args = arguments is [var padCount] ? new SqlExpression[] { instance!, padCount } - : new[] { instance!, arguments[0], arguments[1] }; + : new[] { instance!, arguments[0], TranslateCharArgument(arguments[1], _sqlExpressionFactory) }; var padFunc = _sqlExpressionFactory.Function( method.Name is nameof(string.PadLeft) ? "lpad" : "rpad", @@ -237,12 +237,20 @@ [new CaseWhenClause(_sqlExpressionFactory.GreaterThanOrEqual(lengthFunc, argumen case nameof(string.Join) when arguments is [_, var joinArray] && joinArray.TypeMapping is NpgsqlArrayTypeMapping: { + // string.Join treats a null separator as an empty string, whereas concat_ws and array_to_string return NULL for it. + var separator = arguments[0] switch + { + { } s when s.Type == typeof(char) => TranslateCharArgument(s, _sqlExpressionFactory), + SqlConstantExpression { Value: not null } or ColumnExpression { IsNullable: false } => arguments[0], + _ => _sqlExpressionFactory.Coalesce(arguments[0], _sqlExpressionFactory.Constant(string.Empty, typeof(string))) + }; + // If the array of strings to be joined is a constant (NewArrayExpression), we translate to concat_ws. // Otherwise we translate to array_to_string, which also supports array columns and parameters. if (arguments[1] is PgNewArrayExpression newArrayExpression) { var rewrittenArguments = new SqlExpression[newArrayExpression.Expressions.Count + 1]; - rewrittenArguments[0] = arguments[0]; + rewrittenArguments[0] = separator; for (var i = 0; i < newArrayExpression.Expressions.Count; i++) { @@ -273,7 +281,7 @@ [new CaseWhenClause(_sqlExpressionFactory.GreaterThanOrEqual(lengthFunc, argumen return _sqlExpressionFactory.Function( "array_to_string", - [arguments[1], arguments[0], _sqlExpressionFactory.Constant("")], + [arguments[1], separator, _sqlExpressionFactory.Constant("")], nullable: true, argumentsPropagateNullability: TrueArrays[3], typeof(string)); diff --git a/test/EFCore.PG.FunctionalTests/Query/ArrayArrayQueryTest.cs b/test/EFCore.PG.FunctionalTests/Query/ArrayArrayQueryTest.cs index 6a28ceae75..3114253ea9 100644 --- a/test/EFCore.PG.FunctionalTests/Query/ArrayArrayQueryTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/ArrayArrayQueryTest.cs @@ -1027,6 +1027,57 @@ WHERE array_to_string(s."StringArray", ', ', '') = '3, 4' """); } + [ConditionalFact] + public virtual async Task String_Join_with_space_char_separator_parameter() + { + var separator = ' '; + + await AssertQuery( + ss => ss.Set() + .Where(e => string.Join(separator, e.StringArray) == "3 4")); + + AssertSql( + """ +@separator=' ' (DbType = String) + +SELECT s."Id", s."ArrayContainerEntityId", s."ArrayOfStringConvertedToDelimitedString", s."Byte", s."ByteArray", s."Bytea", s."EnumConvertedToInt", s."EnumConvertedToString", s."IList", s."IntArray", s."IntList", s."ListOfStringConvertedToDelimitedString", s."NonNullableText", s."NullableEnumConvertedToString", s."NullableEnumConvertedToStringWithNonNullableLambda", s."NullableIntArray", s."NullableIntList", s."NullableStringArray", s."NullableStringList", s."NullableText", s."StringArray", s."StringList", s."ValueConvertedArrayOfEnum", s."ValueConvertedListOfEnum", s."Varchar10", s."Varchar15" +FROM "SomeEntities" AS s +WHERE array_to_string(s."StringArray", @separator, '') = '3 4' +"""); + } + + [ConditionalFact] + public virtual async Task String_Join_with_null_separator_parameter() + { + string? separator = null; + + await AssertQuery( + ss => ss.Set() + .Where(e => string.Join(separator, e.StringArray) == "34")); + + AssertSql( + """ +SELECT s."Id", s."ArrayContainerEntityId", s."ArrayOfStringConvertedToDelimitedString", s."Byte", s."ByteArray", s."Bytea", s."EnumConvertedToInt", s."EnumConvertedToString", s."IList", s."IntArray", s."IntList", s."ListOfStringConvertedToDelimitedString", s."NonNullableText", s."NullableEnumConvertedToString", s."NullableEnumConvertedToStringWithNonNullableLambda", s."NullableIntArray", s."NullableIntList", s."NullableStringArray", s."NullableStringList", s."NullableText", s."StringArray", s."StringList", s."ValueConvertedArrayOfEnum", s."ValueConvertedListOfEnum", s."Varchar10", s."Varchar15" +FROM "SomeEntities" AS s +WHERE array_to_string(s."StringArray", COALESCE(NULL, ''), '') = '34' +"""); + } + + [ConditionalFact] + public virtual async Task String_Join_with_nullable_separator_column() + { + await AssertQuery( + ss => ss.Set() + .Where(e => string.Join(e.NullableText, e.StringArray) == "3foo4")); + + AssertSql( + """ +SELECT s."Id", s."ArrayContainerEntityId", s."ArrayOfStringConvertedToDelimitedString", s."Byte", s."ByteArray", s."Bytea", s."EnumConvertedToInt", s."EnumConvertedToString", s."IList", s."IntArray", s."IntList", s."ListOfStringConvertedToDelimitedString", s."NonNullableText", s."NullableEnumConvertedToString", s."NullableEnumConvertedToStringWithNonNullableLambda", s."NullableIntArray", s."NullableIntList", s."NullableStringArray", s."NullableStringList", s."NullableText", s."StringArray", s."StringList", s."ValueConvertedArrayOfEnum", s."ValueConvertedListOfEnum", s."Varchar10", s."Varchar15" +FROM "SomeEntities" AS s +WHERE array_to_string(s."StringArray", COALESCE(s."NullableText", ''), '') = '3foo4' +"""); + } + [ConditionalTheory] [MemberData(nameof(IsAsyncData))] public virtual async Task String_Join_disallow_non_array_type_mapped_parameter(bool async) diff --git a/test/EFCore.PG.FunctionalTests/Query/CharacterQueryNpgsqlTest.cs b/test/EFCore.PG.FunctionalTests/Query/CharacterQueryNpgsqlTest.cs index de07806f6a..762c833bad 100644 --- a/test/EFCore.PG.FunctionalTests/Query/CharacterQueryNpgsqlTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/CharacterQueryNpgsqlTest.cs @@ -188,6 +188,61 @@ LIMIT 2 ]); } + [Theory] + [InlineData('e')] + [InlineData(' ')] + public void Text_conversions_with_char(char character) + { + Fixture.ClearEntities(); + + using var context = CreateContext(); + context.CharacterTestEntities.Add(new CharacterTestEntity { Character8 = "12345678", Character = character }); + context.SaveChanges(); + Fixture.TestSqlLoggerFactory.Clear(); + + var result = context.CharacterTestEntities.Select(e => new + { + Text = e.Character.ToString(), + PadLeft = e.Character8!.PadLeft(10, e.Character), + PadRight = e.Character8!.PadRight(10, e.Character), + PadRightParameter = e.Character8!.PadRight(10, character), + Join = string.Join(e.Character, new[] { e.Character8, e.Character8 }), + JoinParameter = string.Join(character, new[] { e.Character8, e.Character8 }) + }).Single(); + + Assert.Equal( + new + { + Text = character.ToString(), + PadLeft = "12345678".PadLeft(10, character), + PadRight = "12345678".PadRight(10, character), + PadRightParameter = "12345678".PadRight(10, character), + Join = string.Join(character, "12345678", "12345678"), + JoinParameter = string.Join(character, "12345678", "12345678") + }, + result); + + Fixture.TestSqlLoggerFactory.AssertBaseline( + [ + $$""" +@character='{{character}}' (DbType = String) + +SELECT rpad(c."Character", 1) AS "Text", CASE + WHEN length(c."Character8") >= 10 THEN c."Character8" + ELSE lpad(c."Character8", 10, rpad(c."Character", 1)) +END AS "PadLeft", CASE + WHEN length(c."Character8") >= 10 THEN c."Character8" + ELSE rpad(c."Character8", 10, rpad(c."Character", 1)) +END AS "PadRight", CASE + WHEN length(c."Character8") >= 10 THEN c."Character8" + ELSE rpad(c."Character8", 10, @character) +END AS "PadRightParameter", concat_ws(rpad(c."Character", 1), c."Character8", c."Character8") AS "Join", concat_ws(@character, c."Character8", c."Character8") AS "JoinParameter" +FROM "CharacterTestEntities" AS c +LIMIT 2 +""" + ]); + } + #region Fixture // ReSharper disable once ClassNeverInstantiated.Global diff --git a/test/EFCore.PG.FunctionalTests/Query/Translations/MiscellaneousTranslationsNpgsqlTest.cs b/test/EFCore.PG.FunctionalTests/Query/Translations/MiscellaneousTranslationsNpgsqlTest.cs index d03eb59b06..2bab7e170d 100644 --- a/test/EFCore.PG.FunctionalTests/Query/Translations/MiscellaneousTranslationsNpgsqlTest.cs +++ b/test/EFCore.PG.FunctionalTests/Query/Translations/MiscellaneousTranslationsNpgsqlTest.cs @@ -180,6 +180,23 @@ public override async Task Convert_ToInt64() public override Task Convert_ToString() => AssertTranslationFailed(() => base.Convert_ToString()); + [ConditionalFact] + public virtual async Task Convert_ToString_bool() + { + await AssertQuery( + ss => ss.Set().Where(b => Convert.ToString(b.Bool) == "True")); + + AssertSql( + """ +SELECT b."Id", b."Bool", b."Byte", b."ByteArray", b."DateOnly", b."DateTime", b."DateTimeOffset", b."Decimal", b."Double", b."Enum", b."FlagsEnum", b."Float", b."Guid", b."Int", b."Long", b."Short", b."String", b."TimeOnly", b."TimeSpan" +FROM "BasicTypesEntities" AS b +WHERE CASE + WHEN b."Bool" THEN 'True' + WHEN NOT (b."Bool") THEN 'False' +END = 'True' +"""); + } + #endregion Convert #region Parse