Ran clang-format [skip ci]

Author: ankane

examples/citus/example.cpp

@@ -66,7 +66,9 @@ int main() {
 
     std::cout << "Creating distributed table" << std::endl;
     tx2.exec("DROP TABLE IF EXISTS items");
-    tx2.exec("CREATE TABLE items (id bigserial, embedding vector(128), category_id bigint, PRIMARY KEY (id, category_id))");
+    tx2.exec(
+        "CREATE TABLE items (id bigserial, embedding vector(128), category_id bigint, PRIMARY KEY (id, category_id))"
+    );
     tx2.exec("SET citus.shard_count = 4");
     tx2.exec("SELECT create_distributed_table('items', 'category_id')");
 

examples/cohere/example.cpp

@@ -63,18 +63,22 @@ int main() {
     tx.exec("CREATE TABLE documents (id bigserial PRIMARY KEY, content text, embedding bit(1536))");
 
     std::vector<std::string> input{
-        "The dog is barking",
-        "The cat is purring",
-        "The bear is growling"
+        "The dog is barking", "The cat is purring", "The bear is growling"
     };
     std::vector<std::string> embeddings = embed(input, "search_document", api_key);
     for (size_t i = 0; i < input.size(); i++) {
-        tx.exec("INSERT INTO documents (content, embedding) VALUES ($1, $2)", pqxx::params{input[i], embeddings[i]});
+        tx.exec(
+            "INSERT INTO documents (content, embedding) VALUES ($1, $2)",
+            pqxx::params{input[i], embeddings[i]}
+        );
     }
 
     std::string query{"forest"};
     std::string query_embedding = embed({query}, "search_query", api_key)[0];
-    pqxx::result result = tx.exec("SELECT content FROM documents ORDER BY embedding <~> $1 LIMIT 5", pqxx::params{query_embedding});
+    pqxx::result result = tx.exec(
+        "SELECT content FROM documents ORDER BY embedding <~> $1 LIMIT 5",
+        pqxx::params{query_embedding}
+    );
     for (const auto& row : result) {
         std::cout << row[0].as<std::string>() << std::endl;
     }

examples/disco/example.cpp

@@ -36,7 +36,9 @@ Dataset<int, std::string> load_movielens(const std::string& path) {
     while (std::getline(movies_file, line)) {
         std::string::size_type n = line.find('|');
         std::string::size_type n2 = line.find('|', n + 1);
-        movies.emplace(std::make_pair(line.substr(0, n), convert_to_utf8(line.substr(n + 1, n2 - n - 1))));
+        movies.emplace(
+            std::make_pair(line.substr(0, n), convert_to_utf8(line.substr(n + 1, n2 - n - 1)))
+        );
     }
 
     // read ratings and create dataset
@@ -75,7 +77,7 @@ int main() {
     tx.exec("CREATE TABLE movies (name text PRIMARY KEY, factors vector(20))");
 
     Dataset<int, std::string> data = load_movielens(movielens_path);
-    auto recommender = Recommender<int, std::string>::fit_explicit(data, { .factors = 20 });
+    auto recommender = Recommender<int, std::string>::fit_explicit(data, {.factors = 20});
 
     for (const auto& user_id : recommender.user_ids()) {
         pgvector::Vector factors{*recommender.user_factors(user_id)};
@@ -84,19 +86,27 @@ int main() {
 
     for (const auto& item_id : recommender.item_ids()) {
         pgvector::Vector factors{*recommender.item_factors(item_id)};
-        tx.exec("INSERT INTO movies (name, factors) VALUES ($1, $2)", pqxx::params{item_id, factors});
+        tx.exec(
+            "INSERT INTO movies (name, factors) VALUES ($1, $2)", pqxx::params{item_id, factors}
+        );
     }
 
     std::string movie{"Star Wars (1977)"};
     std::cout << "Item-based recommendations for " << movie << std::endl;
-    pqxx::result result = tx.exec("SELECT name FROM movies WHERE name != $1 ORDER BY factors <=> (SELECT factors FROM movies WHERE name = $1) LIMIT 5", pqxx::params{movie});
+    pqxx::result result = tx.exec(
+        "SELECT name FROM movies WHERE name != $1 ORDER BY factors <=> (SELECT factors FROM movies WHERE name = $1) LIMIT 5",
+        pqxx::params{movie}
+    );
     for (const auto& row : result) {
         std::cout << "- " << row[0].as<std::string>() << std::endl;
     }
 
     int user_id = 123;
     std::cout << std::endl << "User-based recommendations for " << user_id << std::endl;
-    result = tx.exec("SELECT name FROM movies ORDER BY factors <#> (SELECT factors FROM users WHERE id = $1) LIMIT 5", pqxx::params{user_id});
+    result = tx.exec(
+        "SELECT name FROM movies ORDER BY factors <#> (SELECT factors FROM users WHERE id = $1) LIMIT 5",
+        pqxx::params{user_id}
+    );
     for (const auto& row : result) {
         std::cout << "- " << row[0].as<std::string>() << std::endl;
     }

examples/hybrid/example.cpp

@@ -26,14 +26,10 @@ std::vector<std::vector<float>> embed(
     }
 
     std::string url{"http://localhost:8080/v1/embeddings"};
-    json data{
-        {"input", input}
-    };
+    json data{{"input", input}};
 
     cpr::Response r = cpr::Post(
-        cpr::Url{url},
-        cpr::Body{data.dump()},
-        cpr::Header{{"Content-Type", "application/json"}}
+        cpr::Url{url}, cpr::Body{data.dump()}, cpr::Header{{"Content-Type", "application/json"}}
     );
     if (r.status_code != 200) {
         throw std::runtime_error{"Bad status: " + std::to_string(r.status_code)};
@@ -53,18 +49,21 @@ int main() {
     pqxx::nontransaction tx{conn};
     tx.exec("CREATE EXTENSION IF NOT EXISTS vector");
     tx.exec("DROP TABLE IF EXISTS documents");
-    tx.exec("CREATE TABLE documents (id bigserial PRIMARY KEY, content text, embedding vector(768))");
+    tx.exec(
+        "CREATE TABLE documents (id bigserial PRIMARY KEY, content text, embedding vector(768))"
+    );
     tx.exec("CREATE INDEX ON documents USING GIN (to_tsvector('english', content))");
 
     std::vector<std::string> input{
-        "The dog is barking",
-        "The cat is purring",
-        "The bear is growling"
+        "The dog is barking", "The cat is purring", "The bear is growling"
     };
     std::vector<std::vector<float>> embeddings = embed(input, "search_document");
 
     for (size_t i = 0; i < input.size(); i++) {
-        tx.exec("INSERT INTO documents (content, embedding) VALUES ($1, $2)", pqxx::params{input[i], pgvector::Vector{embeddings[i]}});
+        tx.exec(
+            "INSERT INTO documents (content, embedding) VALUES ($1, $2)",
+            pqxx::params{input[i], pgvector::Vector{embeddings[i]}}
+        );
     }
 
     std::string sql{R"(
@@ -95,7 +94,8 @@ int main() {
     double k = 60;
     pqxx::result result = tx.exec(sql, pqxx::params{query, pgvector::Vector{query_embedding}, k});
     for (const auto& row : result) {
-        std::cout << "document: " << row[0].as<std::string>() << ", RRF score: " << row[1].as<double>() << std::endl;
+        std::cout << "document: " << row[0].as<std::string>()
+                  << ", RRF score: " << row[1].as<double>() << std::endl;
     }
 
     return 0;

examples/openai/example.cpp

@@ -13,10 +13,7 @@ using json = nlohmann::json;
 // input can be an array with 2048 elements
 std::vector<std::vector<float>> embed(const std::vector<std::string>& input, char* api_key) {
     std::string url{"https://api.openai.com/v1/embeddings"};
-    json data{
-        {"input", input},
-        {"model", "text-embedding-3-small"}
-    };
+    json data{{"input", input}, {"model", "text-embedding-3-small"}};
 
     cpr::Response r = cpr::Post(
         cpr::Url{url},
@@ -48,21 +45,27 @@ int main() {
     pqxx::nontransaction tx{conn};
     tx.exec("CREATE EXTENSION IF NOT EXISTS vector");
     tx.exec("DROP TABLE IF EXISTS documents");
-    tx.exec("CREATE TABLE documents (id bigserial PRIMARY KEY, content text, embedding vector(1536))");
+    tx.exec(
+        "CREATE TABLE documents (id bigserial PRIMARY KEY, content text, embedding vector(1536))"
+    );
 
     std::vector<std::string> input{
-        "The dog is barking",
-        "The cat is purring",
-        "The bear is growling"
+        "The dog is barking", "The cat is purring", "The bear is growling"
     };
     std::vector<std::vector<float>> embeddings = embed(input, api_key);
     for (size_t i = 0; i < input.size(); i++) {
-        tx.exec("INSERT INTO documents (content, embedding) VALUES ($1, $2)", pqxx::params{input[i], pgvector::Vector{embeddings[i]}});
+        tx.exec(
+            "INSERT INTO documents (content, embedding) VALUES ($1, $2)",
+            pqxx::params{input[i], pgvector::Vector{embeddings[i]}}
+        );
     }
 
     std::string query{"forest"};
     std::vector<float> query_embedding = embed({query}, api_key)[0];
-    pqxx::result result = tx.exec("SELECT content FROM documents ORDER BY embedding <=> $1 LIMIT 5", pqxx::params{pgvector::Vector{query_embedding}});
+    pqxx::result result = tx.exec(
+        "SELECT content FROM documents ORDER BY embedding <=> $1 LIMIT 5",
+        pqxx::params{pgvector::Vector{query_embedding}}
+    );
     for (const auto& row : result) {
         std::cout << row[0].as<std::string>() << std::endl;
     }

examples/rdkit/example.cpp

@@ -11,7 +11,9 @@
 
 std::string generate_fingerprint(const std::string& molecule) {
     std::unique_ptr<RDKit::ROMol> mol{RDKit::SmilesToMol(molecule)};
-    std::unique_ptr<ExplicitBitVect> fp{RDKit::MorganFingerprints::getFingerprintAsBitVect(*mol, 3, 2048)};
+    std::unique_ptr<ExplicitBitVect> fp{
+        RDKit::MorganFingerprints::getFingerprintAsBitVect(*mol, 3, 2048)
+    };
     std::stringstream buf;
     for (size_t i = 0; i < fp->getNumBits(); i++) {
         buf << (fp->getBit(i) ? '1' : '0');
@@ -30,12 +32,18 @@ int main() {
     std::vector<std::string> molecules{"Cc1ccccc1", "Cc1ncccc1", "c1ccccn1"};
     for (const auto& molecule : molecules) {
         std::string fingerprint = generate_fingerprint(molecule);
-        tx.exec("INSERT INTO molecules (id, fingerprint) VALUES ($1, $2)", pqxx::params{molecule, fingerprint});
+        tx.exec(
+            "INSERT INTO molecules (id, fingerprint) VALUES ($1, $2)",
+            pqxx::params{molecule, fingerprint}
+        );
     }
 
     std::string query_molecule{"c1ccco1"};
     std::string query_fingerprint = generate_fingerprint(query_molecule);
-    pqxx::result result = tx.exec("SELECT id, fingerprint <%> $1 AS distance FROM molecules ORDER BY distance LIMIT 5", pqxx::params{query_fingerprint});
+    pqxx::result result = tx.exec(
+        "SELECT id, fingerprint <%> $1 AS distance FROM molecules ORDER BY distance LIMIT 5",
+        pqxx::params{query_fingerprint}
+    );
     for (const auto& row : result) {
         std::cout << row[0].as<std::string>() << ": " << row[1].as<double>() << std::endl;
     }

examples/sparse/example.cpp

@@ -20,14 +20,10 @@ using json = nlohmann::json;
 
 std::vector<pgvector::SparseVector> embed(const std::vector<std::string>& inputs) {
     std::string url{"http://localhost:3000/embed_sparse"};
-    json data{
-        {"inputs", inputs}
-    };
+    json data{{"inputs", inputs}};
 
     cpr::Response r = cpr::Post(
-        cpr::Url{url},
-        cpr::Body{data.dump()},
-        cpr::Header{{"Content-Type", "application/json"}}
+        cpr::Url{url}, cpr::Body{data.dump()}, cpr::Header{{"Content-Type", "application/json"}}
     );
     if (r.status_code != 200) {
         throw std::runtime_error{"Bad status: " + std::to_string(r.status_code)};
@@ -51,21 +47,27 @@ int main() {
     pqxx::nontransaction tx{conn};
     tx.exec("CREATE EXTENSION IF NOT EXISTS vector");
     tx.exec("DROP TABLE IF EXISTS documents");
-    tx.exec("CREATE TABLE documents (id bigserial PRIMARY KEY, content text, embedding sparsevec(30522))");
+    tx.exec(
+        "CREATE TABLE documents (id bigserial PRIMARY KEY, content text, embedding sparsevec(30522))"
+    );
 
     std::vector<std::string> input{
-        "The dog is barking",
-        "The cat is purring",
-        "The bear is growling"
+        "The dog is barking", "The cat is purring", "The bear is growling"
     };
     std::vector<pgvector::SparseVector> embeddings = embed(input);
     for (size_t i = 0; i < input.size(); i++) {
-        tx.exec("INSERT INTO documents (content, embedding) VALUES ($1, $2)", pqxx::params{input[i], embeddings[i]});
+        tx.exec(
+            "INSERT INTO documents (content, embedding) VALUES ($1, $2)",
+            pqxx::params{input[i], embeddings[i]}
+        );
     }
 
     std::string query{"forest"};
     pgvector::SparseVector query_embedding = embed({query})[0];
-    pqxx::result result = tx.exec("SELECT content FROM documents ORDER BY embedding <#> $1 LIMIT 5", pqxx::params{query_embedding});
+    pqxx::result result = tx.exec(
+        "SELECT content FROM documents ORDER BY embedding <#> $1 LIMIT 5",
+        pqxx::params{query_embedding}
+    );
     for (const auto& row : result) {
         std::cout << row[0].as<std::string>() << std::endl;
     }

include/pgvector/halfvec.hpp

@@ -39,7 +39,8 @@ class HalfVector {
     explicit HalfVector(std::vector<Half>&& value) : value_{std::move(value)} {}
 
     /// Creates a half vector from a span.
-    explicit HalfVector(std::span<const Half> value) : value_{std::vector<Half>(value.begin(), value.end())} {}
+    explicit HalfVector(std::span<const Half> value) :
+        value_{std::vector<Half>(value.begin(), value.end())} {}
 
     /// Returns the number of dimensions.
     size_t dimensions() const {

include/pgvector/pqxx.hpp

@@ -126,7 +126,11 @@ struct string_traits<pgvector::HalfVector> {
         return pgvector::HalfVector{std::move(values)};
     }
 
-    static std::string_view to_buf(std::span<char> buf, const pgvector::HalfVector& value, ctx c = {}) {
+    static std::string_view to_buf(
+        std::span<char> buf,
+        const pgvector::HalfVector& value,
+        ctx c = {}
+    ) {
         // confirm caller provided estimated buffer space
         if (buf.size() < size_buffer(value)) {
             throw conversion_overrun{"Not enough space in buffer for halfvec"};
@@ -227,7 +231,11 @@ struct string_traits<pgvector::SparseVector> {
         }
     }
 
-    static std::string_view to_buf(std::span<char> buf, const pgvector::SparseVector& value, ctx c = {}) {
+    static std::string_view to_buf(
+        std::span<char> buf,
+        const pgvector::SparseVector& value,
+        ctx c = {}
+    ) {
         // confirm caller provided estimated buffer space
         if (buf.size() < size_buffer(value)) {
             throw conversion_overrun{"Not enough space in buffer for sparsevec"};
@@ -253,7 +261,9 @@ struct string_traits<pgvector::SparseVector> {
                 here += pqxx::into_buf(buf.subspan(here), ",", c);
             }
             // cast to avoid undefined behavior and require less buffer space
-            here += pqxx::into_buf(buf.subspan(here), static_cast<unsigned int>(indices.at(i)) + 1, c);
+            here += pqxx::into_buf(
+                buf.subspan(here), static_cast<unsigned int>(indices.at(i)) + 1, c
+            );
             here += pqxx::into_buf(buf.subspan(here), ":", c);
             here += pqxx::into_buf(buf.subspan(here), values.at(i), c);
         }

include/pgvector/sparsevec.hpp

@@ -20,7 +20,8 @@ namespace pgvector {
 class SparseVector {
   public:
     /// Creates a sparse vector from a dense vector.
-    explicit SparseVector(const std::vector<float>& value) : SparseVector(std::span<const float>{value}) {}
+    explicit SparseVector(const std::vector<float>& value) :
+        SparseVector(std::span<const float>{value}) {}
 
     /// Creates a sparse vector from a span.
     explicit SparseVector(std::span<const float> value) {
@@ -82,7 +83,8 @@ class SparseVector {
     }
 
     friend bool operator==(const SparseVector& lhs, const SparseVector& rhs) {
-        return lhs.dimensions_ == rhs.dimensions_ && lhs.indices_ == rhs.indices_ && lhs.values_ == rhs.values_;
+        return lhs.dimensions_ == rhs.dimensions_ && lhs.indices_ == rhs.indices_
+            && lhs.values_ == rhs.values_;
     }
 
     friend std::ostream& operator<<(std::ostream& os, const SparseVector& value) {