Connect the C++ driver to your database

This driver doesn’t support the vector data type.

DataStax recommends CQL drivers only for Serverless (Non-Vector) databases, existing applications that previously used a CQL-based driver, or if you plan to exclusively use CQL.

It is possible to use CQL drivers for non-vector data in Serverless (Vector) databases. However, DataStax recommends the Data API and clients for Serverless (Vector) databases.

Create your .c file, add connection code, build, and link your application against the C++ driver to connect. This example also includes code to create a CassStatement object to connect to your Astra DB Serverless database, run a CQL query, and print the output to the console.

Prerequisites

Connect to your database

  1. Create a connect_database.c file in the main directory for your C++ project:

    $ cd my_project
    $ touch connect_database.c
  2. Copy the following connection code into the connect_database.c file. You must set the secure_connect_bundle variable to the absolute path of your Astra database credentials file (secure-connect-DATABASE_NAME.zip).

    Do not use the cass_cluster_set_contact_points() and cass_cluster_set_ssl() methods in conjunction with the cass_cluster_set_cloud_secure_connection_bundle() method.

    #include <cassandra.h>
    #include <stdio.h>
    
    int main(int argc, char* argv[]) {
         // Setup and connect to cluster
         CassCluster* cluster = cass_cluster_new();
         CassSession* session = cass_session_new();
    
         // Set up driver to connect to the cloud using the SCB
         const char* secure_connect_bundle = "/SECURE_CONNECT_BUNDLE_PATH/secure-connect-DATABASE_NAME.zip";
         if (cass_cluster_set_cloud_secure_connection_bundle(cluster, secure_connect_bundle) != CASS_OK) {
           fprintf(stderr, "Unable to configure cloud using the SCB: %s\n",
                   secure_connect_bundle);
           return 1;
         }
    
         // Set credentials provided when creating your database
         cass_cluster_set_credentials(cluster, "clientID", "clientSecret");
    
         CassFuture* connect_future = cass_session_connect(session, cluster);
    
         if (cass_future_error_code(connect_future) == CASS_OK) {
           // Use the session to run queries
         } else {
           // Handle error
         }
    
         cass_future_free(connect_future);
         cass_cluster_free(cluster);
         cass_session_free(session);
    
         return 0;
    }
  3. Build and link your application against the C++ driver.

    • Linux or macOS

    • Windows

    For static linking, use cassandra_static.a.

    cc connect_database.c -I/path/to/cassandra.h -L/path/to/cassandra.so -lcassandra

    Include these libraries in your Microsoft Visual Studio project by adding them to the project’s properties under Configuration Properties > Linker > Input > Additional Dependencies.

    Link your application against cassandra.lib. cassandra.dll must be in the runtime path for your application. For static linking, use cassandra_static.lib.

    After connecting to your database, use the following code to query your database. This code creates a CassStatement object to connect to your Astra DB database, runs a CQL query, and prints the output to the console.

    // Build statement and execute query
    const char_ query = "SELECT release_version FROM system.local";
    CassStatement* statement = cass_statement_new(query, 0);
    
    CassFuture* result_future = cass_session_execute(session, statement);
    
    if (cass_future_error_code(result_future) == CASS_OK) {
      // Retrieve result set and get the first row
      const CassResult_ result = cass_future_get_result(result_future);
      const CassRow* row = cass_result_first_row(result);
    
      if (row) {
        const CassValue* value = cass_row_get_column_by_name(row, "release_version");
    
        const char* release_version;
        size_t release_version_length;
        cass_value_get_string(value, &release_version, &release_version_length);
        printf("release_version: '%._s'\n", (int)release_version_length, release_version);
      }
    
        cass_result_free(result);
      } else {
        // Handle error
        const char_ message;
        size_t message_length;
        cass_future_error_message(result_future, &message, &message_length);
        fprintf(stderr, "Unable to run query: '%.*s'\n", (int)message_length, message);
      }
    
      cass_statement_free(statement);
      cass_future_free(result_future);
    }

For installation and data migration instructions, see the C++ driver quickstart.

Was this helpful?

Give Feedback

How can we improve the documentation?

© 2024 DataStax | Privacy policy | Terms of use

Apache, Apache Cassandra, Cassandra, Apache Tomcat, Tomcat, Apache Lucene, Apache Solr, Apache Hadoop, Hadoop, Apache Pulsar, Pulsar, Apache Spark, Spark, Apache TinkerPop, TinkerPop, Apache Kafka and Kafka are either registered trademarks or trademarks of the Apache Software Foundation or its subsidiaries in Canada, the United States and/or other countries. Kubernetes is the registered trademark of the Linux Foundation.

General Inquiries: +1 (650) 389-6000, info@datastax.com