Improved error messages

Author: ankane

include/pgvector/pqxx.hpp

@@ -121,53 +121,47 @@ template <> struct string_traits<pgvector::SparseVector> {
     static constexpr bool converts_from_string{true};
 
     static pgvector::SparseVector from_string(std::string_view text) {
-        try {
-            if (text.size() < 4 || text.front() != '{') {
-                throw conversion_error("Malformed sparsevec literal");
-            }
-
-            size_t n = text.find("}/", 1);
-            if (n == std::string_view::npos) {
-                throw conversion_error("Malformed sparsevec literal");
-            }
+        if (text.size() < 4 || text.front() != '{') {
+            throw conversion_error("Malformed sparsevec literal");
+        }
 
-            int dimensions = std::stoi(std::string(text.substr(n + 2)));
-            if (dimensions < 0) {
-                throw conversion_error("Dimensions cannot be negative");
-            }
+        size_t n = text.find("}/", 1);
+        if (n == std::string_view::npos) {
+            throw conversion_error("Malformed sparsevec literal");
+        }
 
-            std::vector<int> indices;
-            std::vector<float> values;
+        int dimensions = pqxx::from_string<int>(text.substr(n + 2));
+        if (dimensions < 0) {
+            throw conversion_error("Dimensions cannot be negative");
+        }
 
-            if (n > 1) {
-                std::istringstream ss(std::string(text.substr(1, n)));
-                while (ss.good()) {
-                    std::string substr;
-                    std::getline(ss, substr, ',');
+        std::vector<int> indices;
+        std::vector<float> values;
 
-                    size_t ne = substr.find(":");
-                    if (ne == std::string::npos) {
-                        throw conversion_error("Malformed sparsevec literal");
-                    }
+        if (n > 1) {
+            std::istringstream ss(std::string(text.substr(1, n - 1)));
+            while (ss.good()) {
+                std::string substr;
+                std::getline(ss, substr, ',');
 
-                    int index = std::stoi(substr.substr(0, ne));
-                    float value = std::stof(substr.substr(ne + 1));
+                size_t ne = substr.find(":");
+                if (ne == std::string::npos) {
+                    throw conversion_error("Malformed sparsevec literal");
+                }
 
-                    if (index < 1) {
-                        throw conversion_error("Index out of bounds");
-                    }
+                int index = pqxx::from_string<int>(substr.substr(0, ne));
+                float value = pqxx::from_string<float>(substr.substr(ne + 1));
 
-                    indices.push_back(index - 1);
-                    values.push_back(value);
+                if (index < 1) {
+                    throw conversion_error("Index out of bounds");
                 }
-            }
 
-            return pgvector::SparseVector(dimensions, indices, values);
-        } catch (const std::invalid_argument& e) {
-            throw conversion_error("No conversion");
-        } catch (const std::out_of_range& e) {
-            throw conversion_error("Out of range");
+                indices.push_back(index - 1);
+                values.push_back(value);
+            }
         }
+
+        return pgvector::SparseVector(dimensions, indices, values);
     }
 
     static zview to_buf(char* begin, char* end, const pgvector::SparseVector& value) {

test/pqxx_test.cpp

@@ -2,6 +2,7 @@
 #include <optional>
 #include <string>
 #include <vector>
+#include <iostream>
 
 #include <pqxx/pqxx>
 
@@ -245,7 +246,7 @@ void test_sparsevec_from_string() {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{ }/");
         assert(false);
     } catch (const pqxx::conversion_error& e) {
-        assert(std::string_view(e.what()) == "No conversion");
+        assert(std::string_view(e.what()) == "Could not convert '' to int");
     }
 
     try {
@@ -259,7 +260,7 @@ void test_sparsevec_from_string() {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{:}/1");
         assert(false);
     } catch (const pqxx::conversion_error& e) {
-        assert(std::string_view(e.what()) == "No conversion");
+        assert(std::string_view(e.what()) == "Could not convert '' to int");
     }
 
     try {
@@ -287,28 +288,28 @@ void test_sparsevec_from_string() {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{1:4e38}/1");
         assert(false);
     } catch (const pqxx::conversion_error& e) {
-        assert(std::string_view(e.what()) == "Out of range");
+        assert(std::string_view(e.what()) == "Could not convert string to numeric value: '4e38'.");
     }
 
     try {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{a:1}/1");
         assert(false);
     } catch (const pqxx::conversion_error& e) {
-        assert(std::string_view(e.what()) == "No conversion");
+        assert(std::string_view(e.what()) == "Could not convert 'a' to int");
     }
 
     try {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{1:a}/1");
         assert(false);
     } catch (const pqxx::conversion_error& e) {
-        assert(std::string_view(e.what()) == "No conversion");
+        assert(std::string_view(e.what()) == "Could not convert string to numeric value: 'a'.");
     }
 
     try {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{}/a");
         assert(false);
     } catch (const pqxx::conversion_error& e) {
-        assert(std::string_view(e.what()) == "No conversion");
+        assert(std::string_view(e.what()) == "Could not convert 'a' to int");
     }
 }