zhangshenghang commented on code in PR #10048:
URL: https://github.com/apache/seatunnel/pull/10048#discussion_r2538319787


##########
seatunnel-connectors-v2/connector-jdbc/src/main/java/org/apache/seatunnel/connectors/seatunnel/jdbc/internal/dialect/psql/PostgresJdbcRowConverter.java:
##########
@@ -316,4 +366,134 @@ public String microsecondsToIntervalFormatVal(String 
intervalVal) {
         if (seconds > 0) sb.append(seconds).append(" seconds");
         return sb.toString().trim();
     }
+
+    private OffsetDateTime getPostgresOffsetDateTime(ResultSet rs, int 
columnIndex)
+            throws SQLException {
+        // Read the value ONCE to avoid drivers returning null on subsequent 
reads
+        final Object obj;
+        try {
+            obj = rs.getObject(columnIndex);
+        } catch (SQLException e) {
+            log.debug("Failed to get object from ResultSet at column {}", 
columnIndex, e);
+            // Best-effort fallback to string, still only a single read path 
for parsing
+            final String str;
+            try {
+                str = rs.getString(columnIndex);
+            } catch (SQLException se) {
+                log.debug("Failed to get string from ResultSet at column {}", 
columnIndex, se);
+                return null;
+            }
+            return parseTimestampIfPresent(str);
+        }
+
+        if (obj == null) {
+            return null;
+        }
+
+        // Direct types
+        if (obj instanceof OffsetDateTime) {
+            return (OffsetDateTime) obj;
+        }
+        if (obj instanceof Timestamp) {
+            return ((Timestamp) obj).toInstant().atOffset(ZoneOffset.UTC);
+        }
+        if (obj instanceof java.time.ZonedDateTime) {
+            return ((java.time.ZonedDateTime) obj).toOffsetDateTime();
+        }
+        if (obj instanceof java.util.Date) {
+            return ((java.util.Date) obj).toInstant().atOffset(ZoneOffset.UTC);
+        }
+
+        // PostgreSQL specific objects (e.g., PGobject) or any 
org.postgresql.* class
+        final String className = obj.getClass().getName();
+        if (className.startsWith("org.postgresql.")) {
+            String str = null;
+            try {
+                str = obj.toString();
+            } catch (Exception e) {
+                log.debug("Failed to get PostgreSQL timestamp object string 
representation", e);
+            }
+            if (str != null) {
+                OffsetDateTime parsed = parseTimestampIfPresent(str);
+                if (parsed != null) {
+                    return parsed;
+                }
+            }
+        }
+
+        // String-like values
+        if (obj instanceof CharSequence) {
+            return parseTimestampIfPresent(obj.toString());
+        }
+
+        // Last resort: attempt to parse from toString() representation
+        final String str;
+        try {
+            str = String.valueOf(obj);
+        } catch (Throwable ignore) {
+            return null;
+        }
+        return parseTimestampIfPresent(str);
+    }
+
+    private OffsetDateTime parseTimestampIfPresent(String str) throws 
SQLException {
+        if (str == null) {
+            return null;
+        }
+        return parsePostgresTimestampTz(str);
+    }
+
+    private OffsetDateTime parsePostgresTimestampTz(String str) throws 
SQLException {
+        String normalized = normalizeIsoTimestamp(str);
+        if (normalized == null) {
+            return null;
+        }
+
+        try {
+            return OffsetDateTime.parse(normalized);
+        } catch (Exception primary) {
+            log.debug("Failed to parse PostgreSQL timestamptz as ISO-8601: 
{}", str, primary);
+            try {
+                String withoutOffset =
+                        
normalized.replaceFirst("([+-]\\d{2}:?\\d{2}|\\s+UTC|[zZ])$", "");
+                String fallback = withoutOffset.replace('T', ' ').trim();
+                Timestamp ts = Timestamp.valueOf(fallback);
+                return ts.toInstant().atOffset(ZoneOffset.UTC);
+            } catch (Exception secondary) {
+                log.debug(
+                        "Failed to parse PostgreSQL timestamptz as UTC 
timestamp: {}",
+                        str,
+                        secondary);
+                throw new SQLException(
+                        "Failed to parse PostgreSQL timestamptz string: " + 
str, secondary);
+            }
+        }
+    }
+
+    private String normalizeIsoTimestamp(String value) {
+        if (value == null) {
+            return null;
+        }
+
+        String normalized = value.trim();
+        if (normalized.isEmpty()) {
+            return null;
+        }
+        if (normalized.endsWith(" UTC")) {
+            normalized = normalized.substring(0, normalized.length() - 4) + 
"Z";
+        }
+        normalized = normalized.replace(' ', 'T');
+        if (normalized.endsWith("z")) {
+            normalized = normalized.substring(0, normalized.length() - 1) + 
"Z";
+        }

Review Comment:
   Lowercase z or uppercase Z? How about uniformly judging by uppercase?



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to