Desarrollo de aplicaciones con controladores CQL de Cassandra distintos a Java - Lindorm

Aprenda a usar los controladores de C++, Python, Node.js y Go para acceder a Lindorm Table mediante Cassandra Query Language (CQL).

Requisitos previos

Obtenga el endpoint CQL para LindormTable. En la consola de la instancia de Lindorm, haga clic en la pestaña LindormTable, expanda la sección Cassandra-compatible Endpoints y obtenga la dirección VPC o pública correspondiente a CQL Connection. La dirección tiene un formato similar a ld-bp***42. Tanto el nombre de usuario como la contraseña predeterminados son root.
Descargue e instale el controlador correspondiente a su lenguaje de programación. Para obtener más información, consulte Controladores cliente de Cassandra.

Acceso a LindormTable con el controlador CQL de Python

Instale el paquete de dependencias de DataStax para Python. Para obtener más información, consulte Instalación del SDK para 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

A continuación se muestra cómo acceder a 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()

Acceso a LindormTable con el controlador CQL de C++

Descargue el paquete de dependencias de C++. Para obtener más información, consulte Controlador de C++ de DataStax.

A continuación se muestra cómo acceder a 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);

Acceso a LindormTable con el controlador CQL de Node.js

Instale el paquete de dependencias de Node.js.
```
npm install cassandra-driver 
```

A continuación se muestra cómo acceder a 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());

Acceso a LindormTable con el controlador CQL de Go

Instale GoCQL.
```
go get github.com/gocql/gocql
```

A continuación se muestra cómo acceder a 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)
    }
}