[quinnj]

Typed reads with the default PostgresStyle now parse each field from the column text by its declared type instead of going through the OID decoder, which returns Any. Fields of the common types (strings, symbols, enums, integers, floats, Bool, Char, Date, Time, DateTime, UUID, bytea, lazy JSON, timestamps, decimals, vectors of these, and their Nothing/Missing unions) decode without runtime dispatch, so typed reads work in juliac --trim builds. Decoding is also faster: a 10-column typed row takes about a quarter of the time and half the allocations it did on main.

Conversions that worked before still work: integer fields read integral numeric text and float columns printed in exponent form (1e+15), a float4 read into Float64 keeps its Float32 value, Date and Time fields over timestamp columns get the UTC date or time of day, integer arrays convert into Vector{UInt8}, and a registered parser still applies when it returns the field's type. General unions and custom styles keep the OID decoder.

Behavior changes:

• A String field receives any column's text, so json/jsonb columns read as JSON text (this threw before).
• Numeric fields over bool columns throw (they read 1 or 0).
• JSON null in a Union{Nothing, String} field reads as "null"; only SQL NULL becomes nothing.
• A registered parser whose type does not fit the field is skipped, and the field parses the column text.

Also for --trim: the startup message and tuple parameters no longer need runtime dispatch, and Date/DateTime parameters use a static formatter with the same output as string(x).

test/trim_compile_tests.jl restores the JuliaC trim test. It compiles a workload of typed reads, prepared statements, transactions, and parameters, fails on any Postgres.jl verifier error, and runs the executable against PostgreSQL with trust authentication. Released Julia's Base64 (SCRAM) and Dates.CompoundPeriod (intervals) are not trim-safe; those errors are reported but not counted, so --trim=safe still rejects the build. docs/src/support.md says so.

Thanks to @PingoLee for the compatibility matrix that found the float, union, and Time regressions in the first version of this PR.

Version 2.4.0.

Co-authored by Codex

🤖 Generated with Claude Code

[PingoLee]

Thanks for this. I compared typed reads between main and this branch with a matrix: 38 field types (each scalar, Union{Nothing/Missing,…}, a few unions and vectors) × 87 column values (limits, NaN/Infinity, exponent-form floats, long numerics, BC and infinity dates, timestamptz with odd offsets, arrays with NULLs…) × 7 session settings (TimeZone, IntervalStyle, bytea_output, extra_float_digits), about 23,000 reads per side on PostgreSQL 18 and Julia 1.13. Everything under "Behavior changes" reproduced as described, and the Date/DateTime parameter formatter produced the same text as string(x) in every case, including 5-digit and negative years.

Leaving aside pairings that already produced nonsense on main (e.g. an int4 column into a Vector{Int64} field), three regressions aren't in that list:

1. An Int field over a float4/float8 column with a value of 1e15 or more. PostgreSQL prints these in exponent form (SELECT 1e15::float8 returns 1e+15), so pg_parse_integer falls through to Parsers.parse(Int64, "1e+15") and throws ArgumentError. On main the field reads 1000000000000000.

2. Union field types. _text_field(Union{Int64, Float64}) is true, because the union is a subtype of TextField, but nothing lifts text into the union. A Union{Int64, Float64} field over a float8 column now throws MethodError (main: the Float64), and a Union{Int64, String} field over an int8 column now gets a String (main: the Int64).

3. A Time field over a timestamp/timestamptz column. On main it reads the (UTC) time of day, e.g. Time(23, 59, 59, 999, 999); now pg_parse_time throws ArgumentError. It's the counterpart of the Date-from-timestamptz conversion this PR keeps.

A possible fix for all three, which I tried on this branch. With it, every one of these cases reads as on main across all 7 settings, and the full suite passes locally (Julia 1.13, Linux), including the restored trim test: 0 Postgres.jl verifier errors, and the compiled executable runs its workload against the database.

Patch

--- a/src/api/types.jl
+++ b/src/api/types.jl
@@ -409,6 +409,8 @@ end
 
 # timestamp(tz) column into a Date field: the UTC date, as for DateTime fields
 pg_parse_date_any(s::AbstractString)::Date = occursin(':', s) ? Date(pg_parse_datetime_any(s)) : pg_parse_date(s)
+# timestamp(tz) column into a Time field: the UTC time of day
+pg_parse_time_any(s::AbstractString)::Time = occursin(' ', s) ? convert(Time, pg_parse_timestamp(s)) : pg_parse_time(s)
 
 # Integer fields also read integral numeric text such as "12.00" (numeric
 # columns, or SUM over one). Out-of-range values throw InexactError, as when
@@ -423,7 +425,13 @@ function pg_parse_integer(::Type{T}, s::AbstractString) where {T <: Integer}
             wide = Parsers.tryparse(Int128, SubString(s, 1, dot - 1))
         end
     end
-    wide === nothing && return Parsers.parse(T, s)
+    if wide === nothing
+        # float4/float8 columns print large values in exponent form ("1e+16");
+        # numeric never does, so this conversion is exact
+        f = (occursin('e', s) || occursin('E', s)) ? Parsers.tryparse(Float64, s) : nothing
+        f === nothing && return Parsers.parse(T, s)
+        return convert(T, f)
+    end
     return convert(T, wide)
 end
 
@@ -1003,7 +1011,7 @@ const TextField = Union{String, Symbol, Bool, Char, Int8, Int16, Int32, Int64, C
     Date, Time, DateTime, UUID, Vector{UInt8}, JSONType, Vector{String}, Vector{Int16}, Vector{Int32},
     Vector{Int64}, Vector{Float32}, Vector{Float64}, Vector{Bool}, Vector{Date}, Vector{Time},
     Vector{DateTime}, Vector{UUID}, Vector{Char}}
-_text_field(::Type{S}) where {S} = S !== Union{} && (S <: Union{TextField, Enum} || S === IntervalType || _wire_field(S))
+_text_field(::Type{S}) where {S} = S === IntervalType || (S !== Union{} && !(S isa Union) && (S <: Union{TextField, Enum} || _wire_field(S)))
 
 function _field_source(::PostgresStyle, ::Type{T}, v::FieldValue) where {T}
     S = Base.nonnothingtype(Base.nonmissingtype(T))
@@ -1056,7 +1064,7 @@ StructUtils.lift(::AbstractPostgresStyle, ::Type{Cuint}, s::String) = pg_parse_i
 StructUtils.lift(::AbstractPostgresStyle, ::Type{Float32}, s::String) = Parsers.parse(Float32, s), nothing
 StructUtils.lift(::AbstractPostgresStyle, ::Type{Float64}, s::String) = Parsers.parse(Float64, s), nothing
 StructUtils.lift(::AbstractPostgresStyle, ::Type{Date}, s::String) = pg_parse_date_any(s), nothing
-StructUtils.lift(::AbstractPostgresStyle, ::Type{Time}, s::String) = pg_parse_time(s), nothing
+StructUtils.lift(::AbstractPostgresStyle, ::Type{Time}, s::String) = pg_parse_time_any(s), nothing
 StructUtils.lift(::AbstractPostgresStyle, ::Type{DateTime}, s::String) = pg_parse_datetime_any(s), nothing
 StructUtils.lift(::AbstractPostgresStyle, ::Type{UUID}, s::String) = UUID(s), nothing
 StructUtils.lift(::AbstractPostgresStyle, ::Type{IntervalType}, s::String) = parse_interval(s), nothing
--- a/src/array_parsing.jl
+++ b/src/array_parsing.jl
@@ -4,7 +4,7 @@ using Parsers, Dates, UUIDs
 import Durations, DataDecimals
 import ..parse_decimal
 import ..pg_parse_timestamp
-import ..pg_parse_date, ..pg_parse_date_any, ..pg_parse_time, ..pg_parse_datetime_any, ..pg_parse_char, ..pg_parse_integer
+import ..pg_parse_date, ..pg_parse_date_any, ..pg_parse_time, ..pg_parse_time_any, ..pg_parse_datetime_any, ..pg_parse_char, ..pg_parse_integer
 
 const BRACKET_OPEN = UInt8('[')
 const BRACKET_CLOSE = UInt8(']')
@@ -94,7 +94,7 @@ function parse_scalar(token::String, inner_type::Type{T}, quoted::Bool) where {T
     inner_type === Float32 && return Parsers.parse(Float32, token)
     inner_type === Float64 && return Parsers.parse(Float64, token)
     inner_type === Date && return pg_parse_date_any(token)
-    inner_type === Time && return pg_parse_time(token)
+    inner_type === Time && return pg_parse_time_any(token)
     inner_type <: Durations.Timestamp && return pg_parse_timestamp(token, inner_type)
     inner_type === DateTime && return pg_parse_datetime_any(token)
     inner_type === UUID && return UUID(token)

Smaller differences, probably fine either way:

• An Int field over non-integral text (3.5::float8, 12.50::numeric) now throws ArgumentError from Parsers instead of InexactError.
• A Float64 field over a float4 column now reads the printed value, 0.1, instead of the widened Float32, 0.10000000149011612. That matches the text the server sends, but it changes the value silently.
• A Union{Nothing, String} field over a json 'null' now reads "null" instead of nothing. The column isn't SQL NULL, so this looks like a fix.

---

AI use: the edge-case matrix, the suggested fix and the test runs were done with Claude Code (Claude Opus 5.5). I reviewed the results and this comment before posting.

[quinnj-bot]

@PingoLee thanks for the comparison matrix. The three regressions you found are fixed in the merged version, with tests against a live server: float columns parse at their own precision before converting, general unions keep the OID decoder, and Time fields read the UTC time of day from timestamp columns. On your smaller notes: float4 into Float64 keeps the widened Float32 value, JSON null reads as "null", and a non-integral value into an Int field throws InexactError from float columns and ArgumentError from numeric text.

Review found one more case: an integer array column read into a Vector{UInt8} field decoded the array text as bytea. It converts element by element again. This ships in 2.4.0.

AI disclosure: Claude Code reviewed and fixed the PR and drafted this comment.