@@ -202,14 +202,7 @@ public short getShort(int columnIndex) throws SQLException {
 
     @Override
     public int getInt(int columnIndex) throws SQLException {
-        Value val = getCurrentValue(columnIndex);
-        return switch (val) {
-            case Value.Null n -> 0;
-            case Value.Integer i -> (int) i.value();
-            case Value.Float f -> (int) (long) f.value();
-            case Value.Text t -> (int) parseSqliteLong(t.value());
-            case Value.Blob b -> (int) parseSqliteLong(blobAsText(b));
-        };
+        return (int) toLong(getCurrentValue(columnIndex));
     }
 
     @Override
@@ -219,14 +212,7 @@ public long getLong(int columnIndex) throws SQLException {
 
     @Override
     public float getFloat(int columnIndex) throws SQLException {
-        Value val = getCurrentValue(columnIndex);
-        return switch (val) {
-            case Value.Null n -> 0.0F;
-            case Value.Integer i -> (float) (double) i.value();
-            case Value.Float f -> (float) f.value();
-            case Value.Text t -> (float) parseSqliteDouble(t.value());
-            case Value.Blob b -> (float) parseSqliteDouble(blobAsText(b));
-        };
+        return (float) toDouble(getCurrentValue(columnIndex));
     }
 
     @Override
@@ -239,8 +225,9 @@ private static long toLong(Value val) {
             case Value.Null n -> 0L;
             case Value.Integer i -> i.value();
             case Value.Float f -> (long) f.value();
-            case Value.Text t -> parseSqliteLong(t.value());
-            case Value.Blob b -> parseSqliteLong(blobAsText(b));
+            case Value.Text t -> SqliteNumericText.parseLong(t.value());
+            case Value.Blob b ->
+                    SqliteNumericText.parseLong(SqliteNumericText.blobAsText(b.bytes()));
         };
     }
 
@@ -249,116 +236,12 @@ private static double toDouble(Value val) {
             case Value.Null n -> 0.0;
             case Value.Integer i -> (double) i.value();
             case Value.Float f -> f.value();
-            case Value.Text t -> parseSqliteDouble(t.value());
-            case Value.Blob b -> parseSqliteDouble(blobAsText(b));
+            case Value.Text t -> SqliteNumericText.parseDouble(t.value());
+            case Value.Blob b ->
+                    SqliteNumericText.parseDouble(SqliteNumericText.blobAsText(b.bytes()));
         };
     }
 
-    private static String blobAsText(Value.Blob b) {
-        return new String(b.bytes(), java.nio.charset.StandardCharsets.UTF_8);
-    }
-
-    private static long parseSqliteLong(String text) {
-        int length = text.length();
-        int index = skipSqliteWhitespace(text, 0);
-        boolean negative = false;
-        if (index < length && (text.charAt(index) == '+' || text.charAt(index) == '-')) {
-            negative = text.charAt(index) == '-';
-            index++;
-        }
-
-        int digitsStart = index;
-        long value = 0L;
-        boolean overflow = false;
-        while (index < length) {
-            char c = text.charAt(index);
-            if (c < '0' || c > '9') {
-                break;
-            }
-            if (!overflow) {
-                int digit = c - '0';
-                if (value > (Long.MAX_VALUE - digit) / 10) {
-                    overflow = true;
-                } else {
-                    value = value * 10 + digit;
-                }
-            }
-            index++;
-        }
-
-        if (index == digitsStart) {
-            return 0L;
-        }
-        if (overflow) {
-            return negative ? Long.MIN_VALUE : Long.MAX_VALUE;
-        }
-        return negative ? -value : value;
-    }
-
-    private static double parseSqliteDouble(String text) {
-        int length = text.length();
-        int index = skipSqliteWhitespace(text, 0);
-        int start = index;
-        if (index < length && (text.charAt(index) == '+' || text.charAt(index) == '-')) {
-            index++;
-        }
-
-        int digits = 0;
-        while (index < length && isAsciiDigit(text.charAt(index))) {
-            index++;
-            digits++;
-        }
-        if (index < length && text.charAt(index) == '.') {
-            index++;
-            while (index < length && isAsciiDigit(text.charAt(index))) {
-                index++;
-                digits++;
-            }
-        }
-
-        if (digits == 0) {
-            return 0.0;
-        }
-
-        int end = index;
-        if (index < length && (text.charAt(index) == 'e' || text.charAt(index) == 'E')) {
-            int exponentIndex = index + 1;
-            if (exponentIndex < length
-                    && (text.charAt(exponentIndex) == '+' || text.charAt(exponentIndex) == '-')) {
-                exponentIndex++;
-            }
-            int exponentDigits = 0;
-            while (exponentIndex < length && isAsciiDigit(text.charAt(exponentIndex))) {
-                exponentIndex++;
-                exponentDigits++;
-            }
-            if (exponentDigits > 0) {
-                end = exponentIndex;
-            }
-        }
-
-        try {
-            return Double.parseDouble(text.substring(start, end));
-        } catch (NumberFormatException e) {
-            return 0.0;
-        }
-    }
-
-    private static int skipSqliteWhitespace(String text, int index) {
-        while (index < text.length() && isSqliteWhitespace(text.charAt(index))) {
-            index++;
-        }
-        return index;
-    }
-
-    private static boolean isSqliteWhitespace(char c) {
-        return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\u000b' || c == '\f';
-    }
-
-    private static boolean isAsciiDigit(char c) {
-        return c >= '0' && c <= '9';
-    }
-
     @Override
     @Deprecated
     @SuppressWarnings("deprecation")
 
@@ -0,0 +1,121 @@
+package com.github.magnusp.libsql.jdbc;
+
+import java.nio.charset.StandardCharsets;
+
+/**
+ * Parses SQLite's text-to-number coercion, matching the conversion sqlite-jdbc 3.53.4.0 applies
+ * for text and BLOB columns. Extracted verbatim from {@link LibsqlResultSet}.
+ *
+ * <p>Parsing consumes a numeric prefix only, so trailing garbage is ignored. An exponent counts
+ * only when at least one digit follows it. Unparseable text yields {@code 0} or {@code 0.0}, and
+ * integer overflow saturates to {@link Long#MIN_VALUE} or {@link Long#MAX_VALUE}.
+ */
+final class SqliteNumericText {
+
+    private SqliteNumericText() {}
+
+    static long parseLong(String text) {
+        int length = text.length();
+        int index = skipSqliteWhitespace(text, 0);
+        boolean negative = false;
+        if (index < length && (text.charAt(index) == '+' || text.charAt(index) == '-')) {
+            negative = text.charAt(index) == '-';
+            index++;
+        }
+
+        int digitsStart = index;
+        long value = 0L;
+        boolean overflow = false;
+        while (index < length) {
+            char c = text.charAt(index);
+            if (c < '0' || c > '9') {
+                break;
+            }
+            if (!overflow) {
+                int digit = c - '0';
+                if (value > (Long.MAX_VALUE - digit) / 10) {
+                    overflow = true;
+                } else {
+                    value = value * 10 + digit;
+                }
+            }
+            index++;
+        }
+
+        if (index == digitsStart) {
+            return 0L;
+        }
+        if (overflow) {
+            return negative ? Long.MIN_VALUE : Long.MAX_VALUE;
+        }
+        return negative ? -value : value;
+    }
+
+    static double parseDouble(String text) {
+        int length = text.length();
+        int index = skipSqliteWhitespace(text, 0);
+        int start = index;
+        if (index < length && (text.charAt(index) == '+' || text.charAt(index) == '-')) {
+            index++;
+        }
+
+        int digits = 0;
+        while (index < length && isAsciiDigit(text.charAt(index))) {
+            index++;
+            digits++;
+        }
+        if (index < length && text.charAt(index) == '.') {
+            index++;
+            while (index < length && isAsciiDigit(text.charAt(index))) {
+                index++;
+                digits++;
+            }
+        }
+
+        if (digits == 0) {
+            return 0.0;
+        }
+
+        int end = index;
+        if (index < length && (text.charAt(index) == 'e' || text.charAt(index) == 'E')) {
+            int exponentIndex = index + 1;
+            if (exponentIndex < length
+                    && (text.charAt(exponentIndex) == '+' || text.charAt(exponentIndex) == '-')) {
+                exponentIndex++;
+            }
+            int exponentDigits = 0;
+            while (exponentIndex < length && isAsciiDigit(text.charAt(exponentIndex))) {
+                exponentIndex++;
+                exponentDigits++;
+            }
+            if (exponentDigits > 0) {
+                end = exponentIndex;
+            }
+        }
+
+        try {
+            return Double.parseDouble(text.substring(start, end));
+        } catch (NumberFormatException e) {
+            return 0.0;
+        }
+    }
+
+    static String blobAsText(byte[] bytes) {
+        return new String(bytes, StandardCharsets.UTF_8);
+    }
+
+    private static int skipSqliteWhitespace(String text, int index) {
+        while (index < text.length() && isSqliteWhitespace(text.charAt(index))) {
+            index++;
+        }
+        return index;
+    }
+
+    private static boolean isSqliteWhitespace(char c) {
+        return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\u000b' || c == '\f';
+    }
+
+    private static boolean isAsciiDigit(char c) {
+        return c >= '0' && c <= '9';
+    }
+}
@@ -5,10 +5,13 @@
 import com.github.magnusp.libsql.hrana.codec.StmtResult;
 import com.github.magnusp.libsql.hrana.codec.Value;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.Reader;
+import java.math.BigDecimal;
 import java.nio.charset.StandardCharsets;
 import java.sql.Array;
 import java.sql.Blob;
@@ -138,6 +141,39 @@ void textWithLeadingWhitespaceAndTrailingGarbageUsesNumericPrefix() throws SQLEx
         assertNumeric(rs, 1, 42, 42L, 42.0f, 42.0);
     }
 
+    @ParameterizedTest
+    @ValueSource(strings = {" ", "\t", "\n", "\r", "\u000b", "\f"})
+    void everySqliteWhitespaceCharacterIsSkippedBeforeTheNumericPrefix(String whitespace) throws SQLException {
+        LibsqlResultSet rs = resultSet(new Value.Text(whitespace + "42xyz"));
+        assertThat(rs.next()).isTrue();
+        assertNumeric(rs, 1, 42, 42L, 42.0f, 42.0);
+    }
+
+    @Test
+    void largeIntegerTextBelowLongMaxIsReturnedUnchanged() throws SQLException {
+        LibsqlResultSet rs = resultSet(new Value.Text("6000000000000000000"));
+        assertThat(rs.next()).isTrue();
+
+        assertThat(rs.getLong(1)).isEqualTo(6_000_000_000_000_000_000L);
+        assertThat(rs.getBigDecimal(1)).isEqualByComparingTo(new BigDecimal("6000000000000000000"));
+    }
+
+    @Test
+    void textJustPastLongMaxSaturatesToLongMax() throws SQLException {
+        LibsqlResultSet rs = resultSet(new Value.Text("9223372036854775808"));
+        assertThat(rs.next()).isTrue();
+
+        assertThat(rs.getLong(1)).isEqualTo(Long.MAX_VALUE);
+    }
+
+    @Test
+    void textJustPastLongMinSaturatesToLongMin() throws SQLException {
+        LibsqlResultSet rs = resultSet(new Value.Text("-9223372036854775809"));
+        assertThat(rs.next()).isTrue();
+
+        assertThat(rs.getLong(1)).isEqualTo(Long.MIN_VALUE);
+    }
+
     @Test
     void numericBlobIsInterpretedAsText() throws SQLException {
         LibsqlResultSet rs = resultSet(new Value.Blob("123".getBytes(StandardCharsets.UTF_8)));