CassandraDriver driver = new CassandraDriver(); // default : NCPU * 2

int nThreads = 16;
CassandraDriver driver = new CassandraDriver(nThreads);

int nThreads = 16;
EventLoopGroup loop = new NioEventLoopGroup(nThreads);
CassandraDriver driver = new CassandraDriver(loop);

// only seed(s) is required
CassandraCluster cluster = driver.newClusterBuilder()
                                 .addSeed(seed)
                                 .setOptions(CassandraOptions.DEFAULT) // with options
                                 .build();

CassandraOptions.Builder opts = CassandraOptions.newBuilder();

CassandraCluster cluster1 = driver.newClusterBuilder().addSeed(cluster1-seed).build();
CassandraCluster cluster2 = driver.newClusterBuilder().addSeed(cluster2-seed).build();

CassandraOptions opts = CassandraOptions.newBuilder()
                                        .setConsistency(Consistency.LOCAL_ONE)
                                        .mergeFrom(cluster1.options())
                                        .build();
CassandraCluster cluster3 = CassandraCluster.newBuilder()
                                            .setDriver(cluster1.driver())
                                            .setOptions(opts)
                                            .addSeed(cluster3-seed)
                                            .build();

CassandraCluster.EventListener listener = new CassandraCluster.EventListener() { ... };
builder.addEventListener(listener);

cluster.close(); // close all cluster sessions (optional)
driver.shutdown();

CassandraSession session = cluster.session();

CassandraSession session = cluster.session("mykeyspace");

Statement stmt = session.statement(QUERY);
ResultSetFuture future = stmt.executeAsync();

ResultSetFuture future = session.executeAsync(QUERY or STATEMENT);

Statement stmt = session.statement("SELECT * FROM mytable");
stmt.execute();

session.execute("SELECT * FROM mytable");

PreparedStatement pstmt = session.prepareStatement("INSERT INTO mytable (p1, p2) VALUES (?, ?)");
pstmt.setObject("p1", p1);
pstmt.setObject("p2", p2);
pstmt.execute();

session.prepareAndExecute("INSERT INTO mytable (p1, p2) VALUES (?, ?)", p1, p2);

PreparedStatement pstmt = session.prepareStatement("INSERT INTO mytable (p1, p2) VALUES (:myp1, :myp2)");
pstmt.setObject("myp1", p1);
pstmt.setObject("myp2", p2);
pstmt.execute();

Statement stmt = session.statement("INSERT INTO mytable (p1, p2) VALUES (?, ?)", p1, p2);
stmt.execute();

session.execute("INSERT INTO mytable (p1, p2) VALUES (?, ?)", p1, p2);

PreparedStatement pstmt = session.prepareStatement("INSERT INTO mytable (p1, p2) VALUES (?, ?)");

BatchStatement batch = session.batch();
batch.add(pstmt.setObject("p1", p1).setObject("p2", p2))
     .add(pstmt.bind(otherP1, otherP2))
     .add(session.statement("DELETE * FROM mytable WHERE p1=?", oldP1))
     .execute();

stmt.setRoutingPolicy(...);
stmt.setRetryPolicy(...);
stmt.setConsistency(...);
stmt.setSerialConsistency(...);

import static cassandra.cql.query.Query.*;

Select select = select().column("p2").as("myp2")
                        .from("mytable")
                        .where(eq("p1", p1));
select.unprepare(); // one-off prepare
for (Row row : session.execute(select)) {
    // Do something ...
}

Batch batch = batch();
batch.add(insert("mytable1")...)
     .add(update("mytable2")...)
     .add(delete("mytable3")...)
batch.unlogged(); // unlogged batch
session.execute(batch);

for (Row row : session.execute("SELECT * FROM mytable")) {
    // Do something ...
}

ResultSet rs = session.execute("SELECT * FROM mytable");
while (rs.hasNext()) {
    Row row = rs.next();
    // Do something ...
}

// insert dummy data
Batch batch = Query.batch();
for (int i = 0; i < 10000; i++) {
    batch.add(Query.insert("mytable").value("p1", i).value("p2", i));
}
session.execute(batch);

Statement stmt = session.statement("SELECT * FROM mytable");
stmt.setPageSizeLimit(100);
ResultSet rs;

do {
    rs = stmt.execute();
    rs.setAutoPaging(false); // turn-off auto paging

    PagingState pagingState = rs.getPagingState();
    stmt.setPagingState(pagingState);

    for (Row row : rs) {
        // Do something ...
    }
} while (rs.hasMorePages());

import static cassandra.cql.query.Query.*;
...
Select select = select().all().from("mytable");
select.pageSizeLimit(100);

ResultSet rs;
do {
    rs = session.execute(select);
    rs.setAutoPaging(false);

    PagingState pagingState = rs.getPagingState();
    String pagingStateHex = pagingState.toHexString();
    select.pagingState(PagingState.copyFrom(pagingStateHex));

    for (Row row : rs) {
        // Do something ...
    }
} while(rs.hasMorePages());

Statement stmt = session.statement(""SELECT * FROM mytable"");
stmt.setTracing(true);
ResultSet rs = stmt.execute();

Select select = select().all().from("mytable");
select.tracing();
ResultSet rs = session.execute(select);

Trace trace = rs.getLastTrace();
System.out.println(trace.toJsonString());

for (Event e : trace.getEvents()) {
    System.out.println(e.toJsonString());
}

Metadata metadata = cluster.metadata();
metadata.getClusterName();
System.out.println(metadata.toJsonString());

for (KeyspaceMetadata keyspace : metadata.getKeyspaces()) {
    System.out.println(keyspace.toJsonString());

    for (TableMetadata table : keyspace.getTables()) {
        System.out.println(table.toJsonString());

        for (ColumnMetadata column : table.getColumns()) {
            System.out.println(column.toJsonString());
        }
    }
}