Updated exception types

Author: ankane

include/pgvector/pqxx.hpp

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

test/pqxx_test.cpp

@@ -241,12 +241,11 @@ void test_sparsevec_from_string() {
         assert(std::string_view(e.what()) == "Malformed sparsevec literal");
     }
 
-    // TODO change to pqxx::conversion_error
     try {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{ }/");
         assert(false);
-    } catch (const std::invalid_argument& e) {
-        assert(true);
+    } catch (const pqxx::conversion_error& e) {
+        assert(std::string_view(e.what()) == "stoi: no conversion");
     }
 
     try {
@@ -256,12 +255,11 @@ void test_sparsevec_from_string() {
         assert(std::string_view(e.what()) == "Malformed sparsevec literal");
     }
 
-    // TODO change to pqxx::conversion_error
     try {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{:}/1");
         assert(false);
-    } catch (const std::invalid_argument& e) {
-        assert(true);
+    } catch (const pqxx::conversion_error& e) {
+        assert(std::string_view(e.what()) == "stoi: no conversion");
     }
 
     try {
@@ -285,36 +283,32 @@ void test_sparsevec_from_string() {
         assert(std::string_view(e.what()) == "Malformed sparsevec literal");
     }
 
-    // TODO change to pqxx::conversion_error
     try {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{1:4e38}/1");
         assert(false);
-    } catch (const std::out_of_range& e) {
-        assert(true);
+    } catch (const pqxx::conversion_error& e) {
+        assert(std::string_view(e.what()) == "stof: out of range");
     }
 
-    // TODO change to pqxx::conversion_error
     try {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{a:1}/1");
         assert(false);
-    } catch (const std::invalid_argument& e) {
-        assert(true);
+    } catch (const pqxx::conversion_error& e) {
+        assert(std::string_view(e.what()) == "stoi: no conversion");
     }
 
-    // TODO change to pqxx::conversion_error
     try {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{1:a}/1");
         assert(false);
-    } catch (const std::invalid_argument& e) {
-        assert(true);
+    } catch (const pqxx::conversion_error& e) {
+        assert(std::string_view(e.what()) == "stof: no conversion");
     }
 
-    // TODO change to pqxx::conversion_error
     try {
         auto unused = pqxx::from_string<pgvector::SparseVector>("{}/a");
         assert(false);
-    } catch (const std::invalid_argument& e) {
-        assert(true);
+    } catch (const pqxx::conversion_error& e) {
+        assert(std::string_view(e.what()) == "stoi: no conversion");
     }
 }