Improved from_string function for SparseVector

Author: ankane

include/pgvector/pqxx.hpp

@@ -130,23 +130,30 @@ template <> struct string_traits<pgvector::SparseVector> {
             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::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");
-            }
+        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");
+                }
 
-            indices.push_back(std::stoi(substr.substr(0, ne)) - 1);
-            values.push_back(std::stof(substr.substr(ne + 1)));
+                indices.push_back(std::stoi(substr.substr(0, ne)) - 1);
+                values.push_back(std::stof(substr.substr(ne + 1)));
+            }
         }
 
-        int dimensions = std::stoi(std::string(text.substr(n + 2)));
         return pgvector::SparseVector(dimensions, indices, values);
     }
 

test/pqxx_test.cpp

@@ -225,6 +225,67 @@ void test_sparsevec_to_string() {
 
 void test_sparsevec_from_string() {
     assert(pqxx::from_string<pgvector::SparseVector>("{1:1,3:2,5:3}/6") == pgvector::SparseVector({1, 0, 2, 0, 3, 0}));
+    assert(pqxx::from_string<pgvector::SparseVector>("{}/6") == pgvector::SparseVector({0, 0, 0, 0, 0, 0}));
+
+    try {
+        auto unused = pqxx::from_string<pgvector::SparseVector>("");
+        assert(false);
+    } catch (const pqxx::conversion_error& e) {
+        assert(std::string_view(e.what()) == "Malformed sparsevec literal");
+    }
+
+    try {
+        auto unused = pqxx::from_string<pgvector::SparseVector>("{");
+        assert(false);
+    } catch (const pqxx::conversion_error& e) {
+        assert(std::string_view(e.what()) == "Malformed sparsevec literal");
+    }
+
+    try {
+        auto unused = pqxx::from_string<pgvector::SparseVector>("{}/-1");
+        assert(false);
+    } catch (const pqxx::conversion_error& e) {
+        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);
+    }
+
+    try {
+        auto unused = pqxx::from_string<pgvector::SparseVector>("{,}/1");
+        assert(false);
+    } catch (const pqxx::conversion_error& e) {
+        assert(std::string_view(e.what()) == "Malformed sparsevec literal");
+    }
+
+    // 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);
+    }
+
+    // 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);
+    }
+
+    // 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);
+    }
 }
 
 void test_pqxx() {