Lindorm:Develop applications with non-Java Cassandra CQL drivers

Prerequisites

• You have obtained the CQL endpoint for LindormTable, as shown in the figure below.

• Download and install the driver for your programming language. For more information, see Cassandra client drivers.

Access LindormTable with the Python CQL driver

1. Install the DataStax Python dependency package. For more information, see Install the SDK for Python.

   # Install a specific version (Version 3.x is recommended).
   pip install cassandra-driver==3.19.0
   # Install the latest version.
   pip install cassandra-driver

2. The following example shows how to access LindormTable.

   #!/usr/bin/env python
   # -*- coding: UTF-8 -*-
   import logging
   import sys
   from cassandra.cluster import Cluster
   from cassandra.auth import PlainTextAuthProvider
   logging.basicConfig(stream=sys.stdout, level=logging.INFO)
   cluster = Cluster(
       # Enter the CQL endpoint for LindormTable. You do not need to specify the port.
       contact_points=["ld-bp17j28j2y7pm****-proxy-lindorm.lindorm.rds.aliyuncs.com"],
       # Enter your username and password. The default for both is root.
       auth_provider=PlainTextAuthProvider("cassandra", "****"))
   session = cluster.connect()
   # Create a keyspace.
   session.execute(
                   "CREATE KEYSPACE IF NOT EXISTS testKeyspace WITH replication = {'class':'SimpleStrategy', 'replication_factor':1};");
   # Create a table.
   session.execute(
                   "CREATE TABLE IF NOT EXISTS testKeyspace.testTable (id int PRIMARY KEY, name text,age int,address text);");
   # Insert data.
   session.execute(
                   "INSERT INTO testKeyspace.testTable (id, name, age, address) VALUES ( 1, 'testname', 11, 'hangzhou');");
   # Query data.
   rows = session.execute(
                   "SELECT * FROM testKeyspace.testTable ;");
   # Print each row to the console.
   for row in rows:
       print("# row: {}".format(row))
   # Close the session.
   session.shutdown()
   # Shut down the cluster.
   cluster.shutdown()

Access LindormTable with the C++ CQL driver

1. Download the C++ dependency package. For more information, see DataStax C++ Driver.

2. The following example shows how to access LindormTable.

   CassFuture* connect_future = NULL;
   CassCluster* cluster = cass_cluster_new();
   CassSession* session = cass_session_new();
   // Enter the CQL endpoint for LindormTable. You do not need to specify the port.
   char* hosts = "ld-bp17j28j2y7pm****-proxy-lindorm.lindorm.rds.aliyuncs.com";
   // Establish a connection.
   cass_cluster_set_contact_points(cluster, hosts);
   connect_future = cass_session_connect(session, cluster);
   // Execute a query.
   if (cass_future_error_code(connect_future) == CASS_OK) {
       CassFuture* close_future = NULL;
       const char* query = "SELECT  name FROM testKeyspace.testTable ";
       CassStatement* statement = cass_statement_new(query, 0);
       CassFuture* result_future = cass_session_execute(session, statement);
       if (cass_future_error_code(result_future) == CASS_OK) {
         // Obtain the query result.
         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, "name");
           // Print the result.
           const char* name;
           size_t name_length;
           cass_value_get_string(value, &name, &name_length);
           printf("release_version: '%.*s'\n", (int)name_length, name);
         }
         cass_result_free(result);
       } else {
         // Handle exceptions.
         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);
       // Manually release resources.
       close_future = cass_session_close(session);
       cass_future_wait(close_future);
       cass_future_free(close_future);
     } else {
       // Handle exceptions.
       const char* message;
       size_t message_length;
       cass_future_error_message(connect_future, &message, &message_length);
       fprintf(stderr, "Unable to connect: '%.*s'\n", (int)message_length, message);
     }
     cass_future_free(connect_future);
     cass_cluster_free(cluster);
     cass_session_free(session);           

Access LindormTable with the Node.js CQL driver

1. Install the Node.js dependency package.

   npm install cassandra-driver 

2. The following example shows how to access LindormTable.

   const cassandra = require('cassandra-driver');
   /**
   * Enter the CQL endpoint for LindormTable. You do not need to specify the port. Set the DC name to datacenter1.
   * Replace 'Username' and 'Password' with your credentials. The default for both is root.
   */
   const client = new cassandra.Client({ contactPoints: ['ld-bp17j28j2y7pm****-proxy-lindorm.lindorm.rds.aliyuncs.com'], localDataCenter: 'datacenter1', credentials: { username: 'Username', password: 'Password' } });
   client.connect()
   .then(() => client.execute("CREATE KEYSPACE IF NOT EXISTS lindormtest WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '2' }"))
   .then(() => client.execute("CREATE TABLE IF NOT EXISTS lindormtest.nodejs (name text PRIMARY KEY, age int)"))
   .then(() => {
    return client.execute("INSERT INTO lindormtest.nodejs (name, age) VALUES ('lindorm', 10)");
   })
   .then(() => {
    return client.execute("SELECT name, age FROM lindormtest.nodejs WHERE name = 'lindorm' ");
   })
   .then(result => {
    const row = result.first();
    console.log('Obtained row: ', row);
    const p = row.age;
   })
   .finally(() => client.shutdown());
               

Access LindormTable with the Go CQL driver

1. Install GoCQL.

   go get github.com/gocql/gocql

2. The following example shows how to access LindormTable.

   package main
   import (
       "fmt"
       "log"
       "github.com/gocql/gocql"
   )
   func main() {
       // Enter the CQL endpoint for LindormTable. You do not need to specify the port.
       cluster := gocql.NewCluster("ld-bp17j28j2y7pm****-proxy-lindorm.lindorm.rds.aliyuncs.com")
       cluster.Authenticator = gocql.PasswordAuthenticator{
           Username:"Username",
           Password: "Password",
       }
       session, _ := cluster.CreateSession()
       defer session.Close()
       // Create a keyspace.
       if err := session.Query(`CREATE KEYSPACE ks WITH replication = {'class': 'SimpleStrategy', 'replication_factor': 2}`).Exec(); err != nil {
           log.Fatal(err)
       }
       // Create a table.
       if err := session.Query(`CREATE TABLE ks.tb (cn1 text PRIMARY KEY, cn2 text, cn3 text)`).Exec(); err != nil {
           log.Fatal(err)
       }
       // Insert a value.
       if err := session.Query(`INSERT INTO ks.tb (cn1, cn2, cn3) VALUES (?, ?, ?)`,
           "v11", "v12", "v13").Exec(); err != nil {
           log.Fatal(err)
       }
       var column1 string
       var column2 string
       if err := session.Query(`SELECT cn1, cn2 FROM ks.tb WHERE cn1 = ?`,
           "v11").Consistency(gocql.One).Scan(&column1, &column2); err != nil {
           log.Fatal(err)
       }
       fmt.Println("ALL values:", column1, column2)
       var column3 string
       // Iterate over the results.
       iter := session.Query(`SELECT * FROM ks.tb WHERE cn1 = ? `, "v11").Iter()
       for iter.Scan(&column1, &column2, &column3) {
           fmt.Println("ALL value:", column1, column2, column3)
       }
       if err := iter.Close(); err != nil {
           log.Fatal(err)
       }
   }