Develop C/C++ Apps

AttentionThis page documents an earlier version. Go to the latest (v2.1)version.

Pre-requisites

The tutorial assumes that you have:

  • installed YugabyteDB, created a universe and are able to interact with it using the CQL shell. Ifnot, please follow these steps in the quick start guide.
  • have a 32-bit (x86) or 64-bit (x64) architecture machine.
  • have gcc 4.1.2+, Clang 3.4+ installed.

Installing the C/C++ Driver

To get the C/C++ driver run:

  1. $ git clone https://github.com/datastax/cpp-driver.git

Dependencies

The C/C++ driver depends on the following:

  • CMake v2.6.4+
  • libuv 1.x
  • OpenSSL v1.0.x or v1.1.x

More detailed instructions for installing the dependencies aregiven here.

Build and Install

To build and install the driver:

  1. $ mkdir build
  2. $ cd build
  3. $ cmake ..
  4. $ make
  5. $ make install

Working Example

Writing the C/C++ Code.

Create a file ybcql_hello_world.c and copy the contents below:

  1. #include <assert.h>
  2. #include <string.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  6. #include "cassandra.h"
  8. void print_error(CassFuture* future) {
  9.   const char* message;
  10.   size_t message_length;
  11.   cass_future_error_message(future, &message, &message_length);
  12.   fprintf(stderr, "Error: %.*s\n", (int)message_length, message);
  13. }
  15. // Create a new cluster.
  16. CassCluster* create_cluster(const char* hosts) {
  17.   CassCluster* cluster = cass_cluster_new();
  18.   cass_cluster_set_contact_points(cluster, hosts);
  19.   return cluster;
  20. }
  22. // Connect to the cluster given a session.
  23. CassError connect_session(CassSession* session, const CassCluster* cluster) {
  24.   CassError rc = CASS_OK;
  25.   CassFuture* future = cass_session_connect(session, cluster);
  27.   cass_future_wait(future);
  28.   rc = cass_future_error_code(future);
  29.   if (rc != CASS_OK) {
  30.     print_error(future);
  31.   }
  32.   cass_future_free(future);
  34.   return rc;
  35. }
  37. CassError execute_query(CassSession* session, const char* query) {
  38.   CassError rc = CASS_OK;
  39.   CassFuture* future = NULL;
  40.   CassStatement* statement = cass_statement_new(query, 0);
  42.   future = cass_session_execute(session, statement);
  43.   cass_future_wait(future);
  45.   rc = cass_future_error_code(future);
  46.   if (rc != CASS_OK) {
  47.     print_error(future);
  48.   }
  50.   cass_future_free(future);
  51.   cass_statement_free(statement);
  53.   return rc;
  54. }
  56. CassError execute_and_log_select(CassSession* session, const char* stmt) { 
  57.   CassError rc = CASS_OK;
  58.   CassFuture* future = NULL;
  59.   CassStatement* statement = cass_statement_new(stmt, 0);
  61.   future = cass_session_execute(session, statement);
  62.   rc = cass_future_error_code(future);
  63.   if (rc != CASS_OK) {
  64.     print_error(future);
  65.   } else { 
  66.     const CassResult* result = cass_future_get_result(future);
  67.     CassIterator* iterator = cass_iterator_from_result(result);
  68.     if (cass_iterator_next(iterator)) {
  69.       const CassRow* row = cass_iterator_get_row(iterator);
  70.       int age;
  71.       const char* name; size_t name_length;
  72.       const char* language; size_t language_length;
  73.       cass_value_get_string(cass_row_get_column(row, 0), &name, &name_length);
  74.       cass_value_get_int32(cass_row_get_column(row, 1), &age);
  75.       cass_value_get_string(cass_row_get_column(row, 2), &language, &language_length);
  76.       printf ("Select statement returned: Row[%.*s, %d, %.*s]\n", (int)name_length, name, 
  77.           age, (int)language_length, language);
  78.     } else {
  79.       printf("Unable to fetch row!\n");
  80.     }
  82.     cass_result_free(result);
  83.     cass_iterator_free(iterator);
  84.   }
  86.   cass_future_free(future);
  87.   cass_statement_free(statement);
  89.   return rc;
  90. }
  92. int main() {
  93.   // Ensure we log errors.
  94.   cass_log_set_level(CASS_LOG_ERROR);
  96.   CassCluster* cluster = NULL;
  97.   CassSession* session = cass_session_new();
  98.   CassFuture* close_future = NULL;
  99.   char* hosts = "127.0.0.1";
  101.   cluster = create_cluster(hosts);
  103.   if (connect_session(session, cluster) != CASS_OK) {
  104.     cass_cluster_free(cluster);
  105.     cass_session_free(session);
  106.     return -1;
  107.   }
  109.   CassError rc = CASS_OK;
  110.   rc = execute_query(session, "CREATE KEYSPACE IF NOT EXISTS ybdemo");
  111.   if (rc != CASS_OK) return -1;
  112.   printf("Created keyspace ybdemo\n");
  114.   rc = execute_query(session, "DROP TABLE IF EXISTS ybdemo.employee");
  115.   if (rc != CASS_OK) return -1;
  117.   rc = execute_query(session,
  118.                 "CREATE TABLE ybdemo.employee (id int PRIMARY KEY, \
  119.                                               name varchar, \
  120.                                               age int, \
  121.                                               language varchar)");
  122.   if (rc != CASS_OK) return -1;
  123.   printf("Created table ybdemo.employee\n");
  125.   const char* insert_stmt = "INSERT INTO ybdemo.employee (id, name, age, language) VALUES (1, 'John', 35, 'C/C++')";
  126.   rc = execute_query(session, insert_stmt);
  127.   if (rc != CASS_OK) return -1;
  128.   printf("Inserted data: %s\n", insert_stmt);
  130.   const char* select_stmt = "SELECT name, age, language from ybdemo.employee WHERE id = 1";
  131.   rc = execute_and_log_select(session, select_stmt);
  132.   if (rc != CASS_OK) return -1;
  134.   close_future = cass_session_close(session);
  135.   cass_future_wait(close_future);
  136.   cass_future_free(close_future);
  138.   cass_cluster_free(cluster);
  139.   cass_session_free(session);
  141.   return 0;
  142. }

Running the application

You can compile the file using gcc or clang.For clang, you can use:

  1. $ clang ybcql_hello_world.c -lcassandra -Iinclude -o yb_cql_hello_world

Run with:

  1. $ ./yb_cql_hello_world

You should see the following output:

  1. Created keyspace ybdemo
  2. Created table ybdemo.employee
  3. Inserted data: INSERT INTO ybdemo.employee (id, name, age, language) VALUES (1, 'John', 35, 'C/C++')
  4. Select statement returned: Row[John, 35, C/C++]

Pre-requisites

The tutorial assumes that you have:

  • installed YugabyteDB, created a universe and are able to interact with it using the Redis shell. Ifnot please follow these steps in the quick start guide.
  • have C++11.

Installing the Redis C++ Driver

We use the cpp_redis driver. To install the library do the following:

  • Clone the cpp_redis repository
  1. $ git clone https://github.com/Cylix/cpp_redis.git
  • Get the networking module (tacopie)
  1. $ cd cpp_redis
  2. $ git submodule init && git submodule update
  • Create a build directory and move into it
  1. $ mkdir build && cd build
  • Generate the Makefile using CMake
  1. $ cmake .. -DCMAKE_BUILD_TYPE=Release
  • Build and install the library
  1. $ make
  2. $ make install

Writing a hello world redis app

Create a file ybredis_hello_world.cpp and copy the contents below:

  1. #include <cpp_redis/cpp_redis>
  3. #include<iostream>
  4. #include<vector>
  5. #include<string>
  6. #include<utility>
  7. using namespace std;
  9. int main() {
  10.   cpp_redis::client client;
  12.   client.connect("127.0.0.1", 6379, [](const std::string& host, std::size_t port, cpp_redis::client::connect_state status) {
  13.     if (status == cpp_redis::client::connect_state::dropped) {
  14.       std::cout << "client disconnected from " << host << ":" << port << std::endl;
  15.     }
  16.   });
  18.   string userid = "1";
  19.   vector<pair<string, string>> userProfile;
  20.   userProfile.push_back(make_pair("name", "John"));
  21.   userProfile.push_back(make_pair("age", "35"));
  22.   userProfile.push_back(make_pair("language", "Redis"));
  24.   // Insert the data
  25.   client.hmset(userid, userProfile, [](cpp_redis::reply& reply) {
  26.       cout<< "HMSET returned " << reply << ": id=1, name=John, age=35, language=Redis" << endl;
  27.   });
  29.   // Query the data
  30.   client.hgetall(userid, [](cpp_redis::reply& reply) {
  31.     std::vector<cpp_redis::reply> retVal;
  32.     if (reply.is_array()) {
  33.       retVal = reply.as_array();
  34.     }
  35.     cout << "Query result:" <<endl;
  36.     for (int i = 0; i < retVal.size(); i=i+2) {
  37.       cout << retVal[i] << "=" <<retVal[i+1] << endl; 
  38.     }
  39.   });
  41.   // synchronous commit, no timeout
  42.   client.sync_commit();
  44.   return 0;
  45. }

Running the app

To compile the file, run the following command

  1. $ g++ -ltacopie -lcpp_redis -std=c++11 -o ybredis_hello_world ybredis_hello_world.cpp

To run the app do

  1. $ ./ybredis_hello_world

You should see the following output

  1. HMSET returned OK: id=1, name=John, age=35, language=Redis
  2. Query result: 
  3. age=35
  4. language=Redis
  5. name=John