Announcing General Availability of the C++ SDK for Couchbase
Tags: c, couchbase, sdk, opensource
Published: 2024-07-05 09:42:29

---
title: Announcing General Availability of the C++ SDK for Couchbase
published: true
date: 2024-07-01 15:00:48 UTC
tags: C,Couchbase,SDK,opensource
canonical_url: https://www.couchbase.com/blog/announcing-general-availability-of-the-cpp-sdk-for-couchbase/
---

We are thrilled to announce the General Availability (GA) of the [C++ SDK](https://docs.couchbase.com/cxx-sdk/current/hello-world/start-using-sdk.html)for Couchbase! This release adds support for native C++ language to our existing comprehensive set of [SDK libraries](https://docs.couchbase.com/home/index.html) in 11 programming languages and marks a significant milestone in our commitment to providing robust, high-performance tools for developers to build modern, scalable applications. In fact, this C++ SDK is the core library behind our existing [Python](https://docs.couchbase.com/python-sdk/current/hello-world/start-using-sdk.html), [NodeJS](https://docs.couchbase.com/nodejs-sdk/current/hello-world/start-using-sdk.html), [Ruby](https://docs.couchbase.com/ruby-sdk/current/hello-world/start-using-sdk.html), and [PHP](https://docs.couchbase.com/php-sdk/current/hello-world/start-using-sdk.html) SDKs and strives to provide a consistent, performant and efficient experience across all these programming languages.

## Why C++ SDK?

C++ remains a vital language for many developers due to its performance, efficiency, and control over system resources. By introducing the C++ SDK, Couchbase empowers developers to leverage these advantages while taking full benefit of Couchbase’s advanced NoSQL capabilities. Here are some key reasons why this release is a game-changer:

### Performance

C++ is renowned for its speed and low-level memory management, making it ideal for applications where performance is critical. The C++ SDK for Couchbase ensures that you can build high-performance applications without sacrificing speed or efficiency.

### Seamless Integration

The C++ SDK provides seamless integration with Couchbase Server, enabling developers to easily perform operations such as KV operations, SQL++ queries, and transactions. This tight integration ensures that your applications can scale effectively while maintaining high performance.

### Modern API Design

The C++ SDK features a modern, idiomatic API that aligns with the latest C++ standards. This makes it not only powerful but also intuitive for C++ developers, reducing the learning curve and allowing you to start building applications quickly.

## Key Features

Here are some of the standout features of the C++ SDK for Couchbase:

### Easy Connection Management

The C++ SDK simplifies [connection management](https://docs.couchbase.com/cxx-sdk/current/howtos/managing-connections.html), allowing you to establish and manage connections to your Couchbase cluster with minimal effort. This includes handling connection pooling, load balancing, and failover, ensuring your application remains resilient and performant. This means that the SDK can automatically read the topology of your cluster and provide seamless connections during topology changes such as cluster resizes or cluster upgrades. Below is an example of C++ code to connect to your couchbase database.

```
// Attempt to connect to the Couchbase cluster
auto [connect_err, cluster] = couchbase::cluster::connect(config.connection_string, options).get();

if (connect_err) {
    // Output the error message if connection fails
    std::cout << "Unable to connect to the cluster. Error code: " << connect_err.message() << "\n";
} else {
    auto collection = cluster.bucket(config.bucket_name)
                             .scope(config.scope_name)
                             .collection(config.collection_name);

    // d something interesting

    cluster.close().get();
}
```

### Key-Value (KV) Operation Support

The C++ SDK natively supports performing [key value operations](https://docs.couchbase.com/cxx-sdk/current/howtos/kv-operations.html). Key-value operations are unique to couchbase and provide very fast CRUD operations for documents stored in couchbase. Below is an example of C++ code to run a simple KV get & upsert of a document.

```
auto collection = cluster.bucket(config.bucket_name)
                         .scope(config.scope_name)
                         .collection(config.collection_name);

// KV- get
auto record = collection.get(document_id);
std::cout << record.content_as() << "\n";

// create a new document
const std::string document_id{ "minimal_example" };
const tao::json::value basic_doc{
  { "a", 1.0 },
  { "b", 2.0 },
};

// KV 
auto [err, resp] = collection.upsert(document_id, basic_doc, {}).get();
if (err.ec()) {
  std::cout << "ec: " << err.message() << ", ";
} else {
  std::cout << "id: " << document_id << ", CAS: " << resp.cas().value() << "\n";
}

cluster.close().get();
```

### Rich Query, Search and Vector Search Support

The C++ SDK supports [SQL++ queries](https://docs.couchbase.com/cxx-sdk/current/howtos/sqlpp-queries-with-sdk.html), [full-text search](https://docs.couchbase.com/cxx-sdk/current/concept-docs/full-text-search-overview.html) (FTS), and [vector search](https://docs.couchbase.com/cxx-sdk/current/howtos/vector-searching-with-sdk.html), providing you with powerful tools to perform complex data operations. Whether you need to run sophisticated queries or perform full-text searches, the SDK has you covered. 

#### Query Search

Below is a code snippet to execute a simple [SQL++ query](https://docs.couchbase.com/cxx-sdk/current/howtos/sqlpp-queries-with-sdk.html) to fetch records from airlines collection:

```
auto scope = cluster.bucket(config.bucket_name).scope(config.scope_name);
  auto [err, resp] = scope.query("SELECT * FROM airline LIMIT 10").get();
  std::cout << "--- Iterating as JSON objects:\n";
  for (auto row : resp.rows_as_json()) {
    std::cout << "Airline(id: " << row["airline"]["id"] << ", name: \"" << row["airline"]["name"] << "\")\n";
  }
```

#### Full Text Search (FTS)

Below is a code snippet to execute a [FTS query](https://docs.couchbase.com/cxx-sdk/current/concept-docs/full-text-search-overview.html) to do a full text search for “_nice restaurants_” the index created on the landmark collection:

```
auto scope = cluster.bucket(config.bucket_name).scope(config.scope_name);
auto [err, resp] = scope
  .search("travel-inventory-landmarks",
     couchbase::search_request(couchbase::query_string_query("nice restaurants")),
     couchbase::search_options{}.fields({ "content" }))
  .get();
for (const auto& row : resp.rows()) {
  auto fields = row.fields_as<couchbase::codec::tao_json_serializer>();
  std::cout << "score: " << row.score() << ", id: \"" << row.id() << "\", content: \"" << fields["content"].get_string() << "\"\n";
}
```

#### Vector Search

Below is a code snippet to execute a [vector search](https://docs.couchbase.com/cxx-sdk/current/howtos/vector-searching-with-sdk.html) query:

```
auto scope = cluster.bucket(config.bucket_name).scope(config.scope_name);

// weights could be retrieved from your llm model or openAI
std::vector<double> weights{ 0.1, 0.2, 0.3, 0.4 };
auto [err, resp] = scope
  .search("travel-inventory-landmarks",
    couchbase::search_request(couchbase::vector_search(
    couchbase::vector_query(field_name, weights))))
  .get();

for (const auto& row : resp.rows()) {
  auto fields = row.fields_as<couchbase::codec::tao_json_serializer>();
  std::cout << "score: " << row.score() << ", id: \"" << row.id() << "\", content: \"" << fields["content"].get_string() << "\"\n";
}
```

### Asynchronous Programming

The SDK supports [asynchronous programming](https://docs.couchbase.com/cxx-sdk/current/howtos/concurrent-async-apis.html) models, enabling you to build responsive, non-blocking applications. This is particularly useful for high-throughput applications where maintaining responsiveness is essential. Here’s an example of running a transaction in a asynchronous context:

```
std::shared_ptr<async_attempt_context> ctx) -> couchbase::error {
  ctx->get(
    collection,
    some_id,
    // do something in this transaction
}
```

### Transactions

This new C++ SDK includes support for [transactions](https://docs.couchbase.com/cxx-sdk/current/howtos/distributed-acid-transactions-from-the-sdk.html) and replaces our existing C++ transaction support by adding more performance improvements and features. Below is a sample code snippet for create a transaction context:

```
std::shared_ptr<couchbase::transactions::attempt_context> ctx) -> couchbase::error {
  ctx.insert(collection, "doc-a", nlohmann::json({}));
  couchbase::transactions::transaction_get_result doc_a = ctx->get( collection, “doc-a”)
}
```

### Robust Error Handling

[Error handling](https://docs.couchbase.com/cxx-sdk/current/howtos/error-handling.html) is crucial in any application, and the C++ SDK, just like our other SDKs, provides comprehensive error handling capabilities including retry for connection drops, connection pooling and informative error messages. This ensures that you can gracefully handle and recover from errors, enhancing the stability and reliability of your applications.

## Getting Started

To help you get started with the C++ SDK for Couchbase, we’ve prepared a detailed getting started guide on our documentation website. Here’s a quick overview of how to begin:

- 
  - **Install the SDK** : Follow the installation instructions in the documentation<hyperlink> to set up the SDK in your development environment.
  - **Connect to Your Cluster** : Connect to your Couchbase cluster.
  - Perform [CRUD operations](https://docs.couchbase.com/cxx-sdk/current/howtos/kv-operations.html), [run queries](https://docs.couchbase.com/cxx-sdk/current/howtos/sqlpp-queries-with-sdk.html), and leveraging Couchbase’s powerful features.

## Community and Support

We believe in the power of community and open-source development. The C++ SDK for Couchbase [is open-source](https://github.com/couchbase/couchbase-cxx-client), and we encourage you to contribute, provide feedback, and join the conversation. For support, if you are our enterprise licensed customer, you can reach out via support, otherwise, you can access our comprehensive [documentation](https://docs.couchbase.com/cxx-sdk/current/hello-world/start-using-sdk.html), join the [Couchbase Forums](https://www.couchbase.com/forums/) or [Couchbase Discord](https://discord.com/invite/K7NPMPGrPk), or reach out via our [support portal](https://support.couchbase.com/hc/en-us).

## Further Reading

To learn more, check out our documentation website. It goes into more detail on the API, especially around transactions and asynchronous operations and provides other reference material and sample bindings links for you to dig deeper:

- 
  - [Couchbase C++ SDK code examples](https://github.com/couchbase/couchbase-cxx-client/tree/main/examples)
  - [Couchbase C++ SDK documentation](https://docs.couchbase.com/cxx-sdk/current/hello-world/start-using-sdk.html)
  - [Download and install Couchbase C++ SDK](https://github.com/couchbase/couchbase-cxx-client)

[Supported operating systems](https://docs.couchbase.com/cxx-sdk/current/project-docs/compatibility.html) are listed on our documentation website.

Happy coding!

The Couchbase Team

The post [Announcing General Availability of the C++ SDK for Couchbase](https://www.couchbase.com/blog/announcing-general-availability-of-the-cpp-sdk-for-couchbase/) appeared first on [The Couchbase Blog](https://www.couchbase.com/blog).