Connexion et utilisation de LindormTable avec des pilotes Cassandra CQL multilingues - Lindorm

Découvrez comment utiliser les pilotes C++, Python, Node.js et Go pour accéder à Lindorm Table avec le langage de requête Cassandra (CQL).

Prérequis

Récupérez le point de terminaison CQL pour LindormTable. Dans la console de l'instance Lindorm, cliquez sur l'onglet LindormTable, développez la section Cassandra-compatible Endpoints et récupérez l'adresse VPC ou publique pour la CQL Connection. L'adresse ressemble à ld-bp***42. Le nom d'utilisateur et le mot de passe par défaut sont tous deux root.
Téléchargez et installez le pilote correspondant à votre langage de programmation. Pour plus d'informations, consultez la page Pilotes clients Cassandra .

Accéder à LindormTable avec le pilote Python CQL

Installez le package de dépendance DataStax pour Python. Pour plus d'informations, consultez la page Installer le SDK pour 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

L'exemple suivant montre comment accéder à 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()

Accéder à LindormTable avec le pilote C++ CQL

Téléchargez le package de dépendance C++. Pour plus d'informations, consultez la page DataStax C++ Driver.

L'exemple suivant montre comment accéder à 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);

Accéder à LindormTable avec le pilote Node.js CQL

Installez le package de dépendance Node.js.
```
npm install cassandra-driver 
```

L'exemple suivant montre comment accéder à 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());

Accéder à LindormTable avec le pilote Go CQL

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

L'exemple suivant montre comment accéder à 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)
    }
}