switch to version based logic

Author: Wynand

src/parsing.jl

@@ -124,7 +124,7 @@ By default, this uses any existing `parse` method for parsing a value of type `T
 You can implement default PostgreSQL-specific parsing for a given type by overriding
 `pqparse`.
 """
-Base.parse(::Type{T}, pqv::PQValue) where T = pqparse(T, string_view(pqv))
+Base.parse(::Type{T}, pqv::PQValue) where {T} = pqparse(T, string_view(pqv))
 
 """
     LibPQ.pqparse(::Type{T}, str::AbstractString) -> T
@@ -135,9 +135,9 @@ This is used to parse PostgreSQL's output format.
 function pqparse end
 
 # Fallback method
-pqparse(::Type{T}, str::AbstractString) where T = parse(T, str)
+pqparse(::Type{T}, str::AbstractString) where {T} = parse(T, str)
 
-function pqparse(::Type{T}, ptr::Ptr{UInt8}) where T<:Number
+function pqparse(::Type{T}, ptr::Ptr{UInt8}) where {T<:Number}
     return ntoh(unsafe_load(Ptr{T}(ptr)))
 end
 
@@ -147,7 +147,7 @@ pqparse(::Type{Symbol}, str::AbstractString) = Symbol(str)
 function generate_binary_parser(symbol)
     @eval function Base.parse(
         ::Type{T}, pqv::PQBinaryValue{$(oid(symbol))}
-    ) where T<:Number
+    ) where {T<:Number}
         return convert(T, pqparse($(_DEFAULT_TYPE_MAP[symbol]), data_pointer(pqv)))
     end
 end
@@ -295,19 +295,27 @@ end
 
 _DEFAULT_TYPE_MAP[:time] = Time
 function pqparse(::Type{Time}, str::AbstractString)
-    result = nothing
-    try
+    @static if v"1.6.6" <= VERSION < v"1.7.0" || VERSION >= "1.7.2"
         result = tryparse(Time, str)
-    catch err
-        if !(err isa InexactError)
-            rethrow(err)
+        if isnothing(result)
+            # If there's an error we want to see it here
+            result = parse(Time, _trunc_seconds(str))
+        end
+        return result
+    else
+        try
+            return parse(Time, str)
+        catch err
+            if !(err isa InexactError)
+                rethrow(err)
+            end
+            return parse(Time, _trunc_seconds(str))
         end
     end
-    return isnothing(result) ? parse(Time, _trunc_seconds(str)) : result
 end
 
 # InfExtendedTime support for Dates.TimeType
-function pqparse(::Type{InfExtendedTime{T}}, str::AbstractString) where T<:Dates.TimeType
+function pqparse(::Type{InfExtendedTime{T}}, str::AbstractString) where {T<:Dates.TimeType}
     if str == "infinity"
         return InfExtendedTime{T}(∞)
     elseif str == "-infinity"
@@ -372,7 +380,7 @@ end
 
 function pqparse(
     ::Type{InfExtendedTime{T}}, ptr::Ptr{UInt8}
-) where T<:Dates.AbstractDateTime
+) where {T<:Dates.AbstractDateTime}
     microseconds = ntoh(unsafe_load(Ptr{Int64}(ptr)))
     if microseconds == typemax(Int64)
         return InfExtendedTime{T}(∞)
@@ -383,7 +391,7 @@ function pqparse(
     return InfExtendedTime{T}(pqparse(T, ptr))
 end
 
-function pqparse(::Type{InfExtendedTime{T}}, ptr::Ptr{UInt8}) where T<:Date
+function pqparse(::Type{InfExtendedTime{T}}, ptr::Ptr{UInt8}) where {T<:Date}
     microseconds = ntoh(unsafe_load(Ptr{Int32}(ptr)))
     if microseconds == typemax(Int32)
         return InfExtendedTime{T}(∞)
@@ -397,7 +405,7 @@ end
 function generate_binary_date_parser(symbol)
     @eval function Base.parse(
         ::Type{T}, pqv::PQBinaryValue{$(oid(symbol))}
-    ) where T<:TimeType
+    ) where {T<:TimeType}
         return pqparse(T, data_pointer(pqv))
     end
 end
@@ -533,25 +541,25 @@ _DEFAULT_TYPE_MAP[:tsrange] = Interval{DateTime}
 _DEFAULT_TYPE_MAP[:tstzrange] = Interval{ZonedDateTime}
 _DEFAULT_TYPE_MAP[:daterange] = Interval{Date}
 
-function pqparse(::Type{Interval{T}}, str::AbstractString) where T
+function pqparse(::Type{Interval{T}}, str::AbstractString) where {T}
     str == "empty" && return Interval{T}()
     return parse(Interval{T}, str; element_parser=pqparse)
 end
 
 # How to parse range binary fetch is shown here
 # https://github.com/postgres/postgres/blob/31079a4a8e66e56e48bad94d380fa6224e9ffa0d/src/backend/utils/adt/rangetypes.c#L162
-const RANGE_EMPTY =                 0b00000001
+const RANGE_EMPTY = 0b00000001
 const RANGE_LOWER_BOUND_INCLUSIVE = 0b00000010
 const RANGE_UPPER_BOUND_INCLUSIVE = 0b00000100
 const RANGE_LOWER_BOUND_INFINITIY = 0b00001000
 const RANGE_UPPER_BOUND_INFINITIY = 0b00010000
-const RANGE_LOWER_BOUND_NULL =      0b00100000
-const RANGE_UPPER_BOUND_NULL =      0b01000000
+const RANGE_LOWER_BOUND_NULL = 0b00100000
+const RANGE_UPPER_BOUND_NULL = 0b01000000
 
 function generate_range_binary_parser(symbol)
     @eval function Base.parse(
         ::Type{Interval{T}}, pqv::PQBinaryValue{$(oid(symbol))}
-    ) where T
+    ) where {T}
         current_pointer = data_pointer(pqv)
         flags = ntoh(unsafe_load(Ptr{UInt8}(current_pointer)))
         current_pointer += sizeof(UInt8)
@@ -590,13 +598,13 @@ foreach(
 
 ## arrays
 # numeric arrays never have double quotes and always use ',' as a separator
-parse_numeric_element(::Type{T}, str) where T = parse(T, str)
+parse_numeric_element(::Type{T}, str) where {T} = parse(T, str)
 
-function parse_numeric_element(::Type{Union{T,Missing}}, str) where T
+function parse_numeric_element(::Type{Union{T,Missing}}, str) where {T}
     return str == "NULL" ? missing : parse(T, str)
 end
 
-function parse_numeric_array(eltype::Type{T}, str::AbstractString) where T
+function parse_numeric_array(eltype::Type{T}, str::AbstractString) where {T}
     eq_ind = findfirst(isequal('='), str)
 
     if eq_ind !== nothing
@@ -670,7 +678,7 @@ for pq_eltype in ("int2", "int4", "int8", "float4", "float8", "oid", "numeric")
     for jl_eltype in (jl_type, jl_missingtype)
         @eval function pqparse(
             ::Type{A}, str::AbstractString
-        ) where A<:AbstractArray{$jl_eltype}
+        ) where {A<:AbstractArray{$jl_eltype}}
             return parse_numeric_array($jl_eltype, str)::A
         end
     end