binding.cpp

#include <iostream>
#include <vector>
#include <thread>

#include <cassandra.h>

void assert_future_ok(CassFuture* future, const char* message) {
    if (cass_future_error_code(future) == CASS_OK) {
        return;
    }

    const char *error_msg;
    size_t error_msg_len;
    cass_future_error_message(future, &error_msg, &error_msg_len);
    fprintf(stderr, "ERROR: %s: '%.*s'\n", message, (int)error_msg_len, error_msg);

    std::exit(1);
}

std::pair<CassSession*, CassCluster*> connect() {
    CassCluster* cluster = cass_cluster_new();

    if (cass_cluster_set_protocol_version(cluster, CASS_PROTOCOL_VERSION_V4) != CASS_OK) {
        fprintf(stderr, "ERROR: Failed to set protocol version\n");
        std::exit(1);
    }

    cass_cluster_set_contact_points(cluster, "127.0.0.1");

    if (cass_cluster_set_num_threads_io(cluster, std::thread::hardware_concurrency()) != CASS_OK) {
        fprintf(stderr, "ERROR: Failed to set io threads number\n");
        std::exit(1);
    }

    CassSession* session = cass_session_new();
    CassFuture* connect_future = cass_session_connect(session, cluster);
    cass_future_wait(connect_future);

    assert_future_ok(connect_future, "Unable to connect");
    cass_future_free(connect_future);

    return std::make_pair(session, cluster);
}

void make_simple_request(CassSession* session, const char *query) {
    CassStatement* statement = cass_statement_new(query, 0);

    CassFuture *query_future = cass_session_execute(session, statement);
    cass_future_wait(query_future);

    assert_future_ok(query_future, "Simple request failed");

    cass_statement_free(statement);
    cass_future_free(query_future);
}

int main() {
    auto [session, cluster] = connect();

    make_simple_request(session, "CREATE KEYSPACE IF NOT EXISTS ks WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 1};");
    make_simple_request(session, "CREATE TABLE IF NOT EXISTS ks.test(id int, somestring text, PRIMARY KEY(id));");

    CassFuture* prepare_future
    = cass_session_prepare(session, "INSERT INTO ks.test (id, somestring) VALUES (?, ?)");
    assert_future_ok(prepare_future, "Prepare failed");
    const CassPrepared* prepared = cass_future_get_prepared(prepare_future);
    cass_future_free(prepare_future);

    {
        CassStatement* statement = cass_prepared_bind(prepared);
        printf("bind 1 id: %d\n", cass_statement_bind_int32_by_name(statement, "id", 123));
        printf("bind 1 somestring: %d\n", cass_statement_bind_string_by_name(statement, "somestring", "asdasdasda"));
        CassFuture* execute_future = cass_session_execute(session, statement);
        assert_future_ok(execute_future, "Prepared statement failed");
        printf("execute 1: %d\n", cass_future_error_code(execute_future));
        cass_future_free(execute_future);
    }
    
    {
        CassStatement* statement = cass_prepared_bind(prepared);
        printf("bind 2 id: %d\n", cass_statement_bind_int32_by_name(statement, "id", 1234));
        printf("bind 2 somestring: %d\n", cass_statement_bind_int32_by_name(statement, "somestring", 1234));
        CassFuture* execute_future = cass_session_execute(session, statement);
        printf("execute 2: %d\n", cass_future_error_code(execute_future));
        cass_future_free(execute_future);
    }


    std::cout << "DONE!" << std::endl;

    cass_session_free(session);
    cass_cluster_free(cluster);
    return 0;
}