Lindorm:Desenvolva aplicações com drivers Cassandra CQL não Java

Pré-requisitos

• Obtenha o endpoint CQL do LindormTable, conforme mostra a figura a seguir.

• Baixe e instale o driver da sua linguagem de programação. Para mais detalhes, consulte Drivers de cliente Cassandra.

Acesse o LindormTable com o driver CQL Python

1. Instale o pacote de dependências DataStax Python. Para mais informações, consulte Instalar o 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

2. O exemplo a seguir mostra como acessar o 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()

Acesse o LindormTable com o driver CQL C++

1. Baixe o pacote de dependências C++. Para mais informações, consulte Driver C++ DataStax.

2. Veja abaixo um exemplo de acesso ao 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);           

Acesse o LindormTable com o driver CQL Node.js

1. Instale o pacote de dependências Node.js.

   npm install cassandra-driver 

2. Use o código a seguir como referência para acessar o 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());
               

Acesse o LindormTable com o driver CQL Go

1. Instale o GoCQL.

   go get github.com/gocql/gocql

2. Este exemplo demonstra como se conectar ao 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)
       }
   }