fix(Postgres): decode int/bool/float/date columns by typeName

Wire up PgDecoder.ParseValue so values are returned with their proper
SqlValueKind instead of falling through as Text. Without this, every
non-string column came back as Kind=Text and SqlValue.AsInt() returned
null, which caused downstream callers (e.g. positional row mappers) to
default numeric and boolean fields to 0/false.

Also fix a netstandard2.0 build break in ParseBytea where
byte.TryParse(ReadOnlySpan<char>, ...) is unavailable on that target.

Bump version to 1.9.48.

Author: vkuttyp

Directory.Build.props

@@ -7,6 +7,6 @@
     <Authors>vkuttyp</Authors>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <RepositoryUrl>https://github.com/vkuttyp/CosmoSQLClient-Dotnet</RepositoryUrl>
-    <Version>1.9.47</Version>
+    <Version>1.9.48</Version>
   </PropertyGroup>
 </Project>

src/CosmoSQLClient.Postgres/Proto/PgDecoder.cs

@@ -1,4 +1,5 @@
 using System.Buffers;
+using System.Globalization;
 using System.Text;
 using Cosmo.Transport.Pipelines;
 using CosmoSQLClient.Core;
@@ -43,16 +44,17 @@ public static SqlRow ParseDataRow(ReadOnlySequence<byte> body, IReadOnlyList<Sql
             {
                 var valSeq = body.Slice(reader.Consumed, len);
                 reader.Advance(len);
+                var typeName = i < columns.Count ? columns[i].TypeName : string.Empty;
 #if NETSTANDARD2_0
-                values[i] = SqlValue.From(Encoding.UTF8.GetString(valSeq.ToArray()));
+                values[i] = ParseValue(typeName, Encoding.UTF8.GetString(valSeq.ToArray()));
 #else
                 if (valSeq.IsSingleSegment) 
                 {
-                    values[i] = SqlValue.From(Encoding.UTF8.GetString(valSeq.First.Span));
+                    values[i] = ParseValue(typeName, Encoding.UTF8.GetString(valSeq.First.Span));
                 } 
                 else 
                 {
-                    values[i] = SqlValue.From(Encoding.UTF8.GetString(valSeq.ToArray()));
+                    values[i] = ParseValue(typeName, Encoding.UTF8.GetString(valSeq.ToArray()));
                 }
 #endif
             }
@@ -107,6 +109,74 @@ private static string ReadNullTerminatedString(ref SequenceReader<byte> reader)
         1082 => "date", 1114 => "timestamp", 1184 => "timestamptz",
         1700 => "numeric", 2950 => "uuid", _ => oid.ToString()
     };
+
+    private static SqlValue ParseValue(string typeName, string text)
+    {
+        switch (typeName.ToLowerInvariant())
+        {
+            case "bool":
+                return bool.TryParse(text, out var b) ? SqlValue.From(b) : SqlValue.From(text == "1" || text.Equals("t", StringComparison.OrdinalIgnoreCase));
+            case "int2":
+            case "int4":
+            case "int8":
+                return long.TryParse(text, NumberStyles.Integer, CultureInfo.InvariantCulture, out var l)
+                    ? SqlValue.From(l)
+                    : SqlValue.From(text);
+            case "float4":
+            case "float8":
+                return double.TryParse(text, NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out var d)
+                    ? SqlValue.From(d)
+                    : SqlValue.From(text);
+            case "numeric":
+                return decimal.TryParse(text, NumberStyles.Number, CultureInfo.InvariantCulture, out var dec)
+                    ? SqlValue.From(dec)
+                    : SqlValue.From(text);
+            case "uuid":
+                return Guid.TryParse(text, out var g) ? SqlValue.From(g) : SqlValue.From(text);
+            case "date":
+            case "timestamp":
+                return DateTime.TryParse(text, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var dt)
+                    ? SqlValue.From(dt)
+                    : SqlValue.From(text);
+            case "timestamptz":
+                return DateTimeOffset.TryParse(text, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var dto)
+                    ? SqlValue.From(dto)
+                    : SqlValue.From(text);
+            case "bytea":
+                return ParseBytea(text);
+            default:
+                return SqlValue.From(text);
+        }
+    }
+
+    private static SqlValue ParseBytea(string text)
+    {
+        if (string.IsNullOrEmpty(text))
+            return SqlValue.EmptyString_;
+
+        if (text.StartsWith("\\x", StringComparison.OrdinalIgnoreCase))
+        {
+            int hexLen = text.Length - 2;
+            if (hexLen % 2 == 0)
+            {
+                var bytes = new byte[hexLen / 2];
+                for (int i = 0; i < bytes.Length; i++)
+                {
+#if NETSTANDARD2_0
+                    if (!byte.TryParse(text.Substring(2 + i * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var b))
+                        return SqlValue.From(text);
+#else
+                    if (!byte.TryParse(text.AsSpan(2 + i * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var b))
+                        return SqlValue.From(text);
+#endif
+                    bytes[i] = b;
+                }
+                return SqlValue.From(bytes);
+            }
+        }
+
+        return SqlValue.From(text);
+    }
 }
 
 internal interface IPostgresTokenHandler