Cassandra - Guide rapide

Apache Cassandra est une base de données distribuée hautement évolutive et hautes performances conçue pour gérer de grandes quantités de données sur de nombreux serveurs de base, offrant une haute disponibilité sans point de défaillance unique. C'est un type de base de données NoSQL. Voyons d'abord ce que fait une base de données NoSQL.

NoSQLDatabase

Une base de données NoSQL (parfois appelée Not Only SQL) est une base de données qui fournit un mécanisme pour stocker et récupérer des données autres que les relations tabulaires utilisées dans les bases de données relationnelles. Ces bases de données sont sans schéma, prennent en charge une réplication facile, ont une API simple, finalement cohérente et peuvent gérer d'énormes quantités de données.

L'objectif principal d'une base de données NoSQL est d'avoir

simplicité de conception,
mise à l'échelle horizontale, et
contrôle plus fin de la disponibilité.

Les bases de données NoSql utilisent des structures de données différentes des bases de données relationnelles. Cela accélère certaines opérations dans NoSQL. L'adéquation d'une base de données NoSQL donnée dépend du problème qu'elle doit résoudre.

NoSQL vs base de données relationnelle

Le tableau suivant répertorie les points qui différencient une base de données relationnelle d'une base de données NoSQL.

Base de données relationnelle	Base de données NoSql
Prend en charge un langage de requête puissant.	Prend en charge un langage de requête très simple.
Il a un schéma fixe.	Pas de schéma fixe.
Suit ACID (atomicité, cohérence, isolation et durabilité).	C'est seulement «finalement cohérent».
Prend en charge les transactions.	Ne prend pas en charge les transactions.

Outre Cassandra, nous avons les bases de données NoSQL suivantes qui sont très populaires -

Apache HBase- HBase est une base de données open source, non relationnelle et distribuée, inspirée du BigTable de Google et écrite en Java. Il est développé dans le cadre du projet Apache Hadoop et s'exécute sur HDFS, fournissant des fonctionnalités de type BigTable pour Hadoop.
MongoDB - MongoDB est un système de base de données multi-plateforme orienté document qui évite d'utiliser la structure de base de données relationnelle traditionnelle basée sur des tables au profit de documents de type JSON avec des schémas dynamiques rendant l'intégration des données dans certains types d'applications plus facile et plus rapide.

Qu'est-ce qu'Apache Cassandra?

Apache Cassandra est un système de stockage (base de données) open source, distribué et décentralisé / distribué, permettant de gérer de très grandes quantités de données structurées réparties à travers le monde. Il fournit un service hautement disponible sans point de défaillance unique.

Voici quelques-uns des points notables d'Apache Cassandra -

Il est évolutif, tolérant aux pannes et cohérent.
C'est une base de données orientée colonnes.
Sa conception de distribution est basée sur Dynamo d'Amazon et son modèle de données sur Bigtable de Google.
Créé chez Facebook, il diffère fortement des systèmes de gestion de bases de données relationnelles.
Cassandra implémente un modèle de réplication de type Dynamo sans point de défaillance unique, mais ajoute un modèle de données de «famille de colonnes» plus puissant.
Cassandra est utilisé par certaines des plus grandes entreprises telles que Facebook, Twitter, Cisco, Rackspace, ebay, Twitter, Netflix, etc.

Caractéristiques de Cassandra

Cassandra est devenue si populaire en raison de ses caractéristiques techniques exceptionnelles. Voici quelques-unes des fonctionnalités de Cassandra:

Elastic scalability- Cassandra est hautement évolutive; il permet d'ajouter plus de matériel pour accueillir plus de clients et plus de données selon les besoins.
Always on architecture - Cassandra n'a pas de point de défaillance unique et est disponible en permanence pour les applications stratégiques qui ne peuvent pas se permettre une défaillance.
Fast linear-scale performance- Cassandra est linéairement évolutif, c'est-à-dire qu'il augmente votre débit à mesure que vous augmentez le nombre de nœuds dans le cluster. Par conséquent, il maintient un temps de réponse rapide.
Flexible data storage- Cassandra prend en charge tous les formats de données possibles, notamment: structurés, semi-structurés et non structurés. Il peut s'adapter de manière dynamique aux modifications de vos structures de données en fonction de vos besoins.
Easy data distribution - Cassandra offre la flexibilité de distribuer les données là où vous en avez besoin en répliquant les données sur plusieurs centres de données.
Transaction support - Cassandra prend en charge des propriétés telles que l'atomicité, la cohérence, l'isolement et la durabilité (ACID).
Fast writes- Cassandra a été conçu pour fonctionner avec du matériel de base bon marché. Il effectue des écritures extrêmement rapides et peut stocker des centaines de téraoctets de données, sans sacrifier l'efficacité de lecture.

Histoire de Cassandra

Cassandra a été développé sur Facebook pour la recherche dans la boîte de réception.
Il a été open-source par Facebook en juillet 2008.
Cassandra a été acceptée dans Apache Incubator en mars 2009.
Il s'agit d'un projet Apache de premier niveau depuis février 2010.

L'objectif de conception de Cassandra est de gérer les charges de travail Big Data sur plusieurs nœuds sans aucun point de défaillance unique. Cassandra dispose d'un système distribué peer-to-peer sur ses nœuds et les données sont réparties entre tous les nœuds d'un cluster.

Tous les nœuds d'un cluster jouent le même rôle. Chaque nœud est indépendant et en même temps interconnecté à d'autres nœuds.
Chaque nœud d'un cluster peut accepter des demandes de lecture et d'écriture, quel que soit l'emplacement réel des données dans le cluster.
Lorsqu'un nœud tombe en panne, les demandes de lecture / écriture peuvent être servies à partir d'autres nœuds du réseau.

Réplication de données dans Cassandra

Dans Cassandra, un ou plusieurs des nœuds d'un cluster agissent comme des répliques pour une donnée donnée. S'il est détecté que certains des nœuds ont répondu avec une valeur obsolète, Cassandra renverra la valeur la plus récente au client. Après avoir renvoyé la valeur la plus récente, Cassandra effectue unread repair en arrière-plan pour mettre à jour les valeurs périmées.

La figure suivante montre une vue schématique de la façon dont Cassandra utilise la réplication de données entre les nœuds d'un cluster pour garantir l'absence de point de défaillance unique.

Note - Cassandra utilise le Gossip Protocol en arrière-plan pour permettre aux nœuds de communiquer entre eux et de détecter tout nœud défectueux dans le cluster.

Composants de Cassandra

Les composants clés de Cassandra sont les suivants -

Node - C'est le lieu de stockage des données.
Data center - C'est une collection de nœuds liés.
Cluster - Un cluster est un composant qui contient un ou plusieurs centres de données.
Commit log- Le journal de validation est un mécanisme de reprise après incident dans Cassandra. Chaque opération d'écriture est écrite dans le journal de validation.
Mem-table- Une table mémoire est une structure de données résidant en mémoire. Après le journal de validation, les données seront écrites dans la table mem. Parfois, pour une famille à une seule colonne, il y aura plusieurs tables mem.
SSTable - Il s'agit d'un fichier disque vers lequel les données sont vidées de la table mem lorsque son contenu atteint une valeur seuil.
Bloom filter- Ce ne sont que des algorithmes rapides et non déterministes pour tester si un élément est membre d'un ensemble. C'est un type spécial de cache. Les filtres Bloom sont accessibles après chaque requête.

Langue de requête Cassandra

Les utilisateurs peuvent accéder à Cassandra via ses nœuds en utilisant Cassandra Query Language (CQL). CQL traite la base de données(Keyspace)en tant que conteneur de tables. Les programmeurs utilisentcqlsh: une invite à travailler avec CQL ou des pilotes de langage d'application distincts.

Les clients approchent l'un des nœuds pour leurs opérations de lecture-écriture. Ce nœud (coordinateur) joue un proxy entre le client et les nœuds contenant les données.

Écrire des opérations

Chaque activité d'écriture des nœuds est capturée par le commit logsécrit dans les nœuds. Plus tard, les données seront capturées et stockées dans lemem-table. Chaque fois que la table mem-table est pleine, les données seront écrites dans le SStablefichier de données. Toutes les écritures sont automatiquement partitionnées et répliquées dans tout le cluster. Cassandra consolide périodiquement les SSTables, supprimant les données inutiles.

Lire les opérations

Pendant les opérations de lecture, Cassandra obtient des valeurs de la table mem et vérifie le filtre de floraison pour trouver le SSTable approprié qui contient les données requises.

Le modèle de données de Cassandra est très différent de ce que nous voyons normalement dans un SGBDR. Ce chapitre donne un aperçu de la façon dont Cassandra stocke ses données.

Grappe

La base de données Cassandra est distribuée sur plusieurs machines qui fonctionnent ensemble. Le conteneur le plus externe est connu sous le nom de cluster. Pour la gestion des pannes, chaque nœud contient une réplique et en cas de panne, la réplique prend en charge. Cassandra organise les nœuds dans un cluster, dans un format en anneau, et leur attribue des données.

Espace clé

Keyspace est le conteneur le plus externe pour les données dans Cassandra. Les attributs de base d'un espace clé dans Cassandra sont -

Replication factor - Il s'agit du nombre de machines du cluster qui recevront des copies des mêmes données.
Replica placement strategy- Ce n'est rien d'autre que la stratégie de placer des répliques sur le ring. Nous avons des stratégies telles quesimple strategy (stratégie rackable), old network topology strategy (stratégie sensible au rack), et network topology strategy (stratégie partagée par le centre de données).
Column families- Keyspace est un conteneur pour une liste d'une ou plusieurs familles de colonnes. Une famille de colonnes, à son tour, est un conteneur d'une collection de lignes. Chaque ligne contient des colonnes ordonnées. Les familles de colonnes représentent la structure de vos données. Chaque espace de clés a au moins une et souvent plusieurs familles de colonnes.

La syntaxe de création d'un Keyspace est la suivante -

CREATE KEYSPACE Keyspace name
WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};

L'illustration suivante montre une vue schématique d'un Keyspace.

Famille de colonnes

Une famille de colonnes est un conteneur pour une collection ordonnée de lignes. Chaque ligne, à son tour, est une collection ordonnée de colonnes. Le tableau suivant répertorie les points qui différencient une famille de colonnes d'une table de bases de données relationnelles.

Table relationnelle	Famille de colonnes Cassandra
Un schéma dans un modèle relationnel est fixe. Une fois que nous avons défini certaines colonnes pour une table, lors de l'insertion de données, dans chaque ligne, toutes les colonnes doivent être remplies au moins avec une valeur nulle.	Dans Cassandra, bien que les familles de colonnes soient définies, les colonnes ne le sont pas. Vous pouvez à tout moment ajouter librement n'importe quelle colonne à n'importe quelle famille de colonnes.
Les tables relationnelles définissent uniquement des colonnes et l'utilisateur remplit la table avec des valeurs.	Dans Cassandra, une table contient des colonnes ou peut être définie comme une famille de super colonnes.

Une famille de colonnes Cassandra possède les attributs suivants:

keys_cached - Il représente le nombre d'emplacements à conserver en cache par SSTable.
rows_cached - Il représente le nombre de lignes dont tout le contenu sera mis en cache en mémoire.
preload_row_cache - Il spécifie si vous souhaitez pré-remplir le cache de lignes.

Note − Contrairement aux tables relationnelles où le schéma d'une famille de colonnes n'est pas fixe, Cassandra ne force pas les lignes individuelles à avoir toutes les colonnes.

La figure suivante montre un exemple de famille de colonnes Cassandra.

Colonne

Une colonne est la structure de données de base de Cassandra avec trois valeurs, à savoir le nom de la clé ou de la colonne, la valeur et un horodatage. Ci-dessous, la structure d'une colonne.

SuperColonne

Une super colonne est une colonne spéciale, c'est donc aussi une paire clé-valeur. Mais une super colonne stocke une carte de sous-colonnes.

En général, les familles de colonnes sont stockées sur disque dans des fichiers individuels. Par conséquent, pour optimiser les performances, il est important de conserver les colonnes que vous êtes susceptible d'interroger ensemble dans la même famille de colonnes, et une super colonne peut être utile ici.Voici la structure d'une super colonne.

Modèles de données de Cassandra et SGBDR

Le tableau suivant répertorie les points qui différencient le modèle de données de Cassandra de celui d'un SGBDR.

SGBDR	Cassandra
Le SGBDR traite des données structurées.	Cassandra traite des données non structurées.
Il a un schéma fixe.	Cassandra a un schéma flexible.
Dans le SGBDR, une table est un tableau de tableaux. (RANGÉE x COLONNE)	Dans Cassandra, une table est une liste de «paires clé-valeur imbriquées». (ROW x COLUMN key x COLUMN value)
La base de données est le conteneur le plus externe qui contient les données correspondant à une application.	Keyspace est le conteneur le plus extérieur qui contient les données correspondant à une application.
Les tables sont les entités d'une base de données.	Les tables ou familles de colonnes sont l'entité d'un espace de clés.
Row est un enregistrement individuel dans le SGBDR.	Row est une unité de réplication dans Cassandra.
La colonne représente les attributs d'une relation.	La colonne est une unité de stockage à Cassandra.
SGBDR prend en charge les concepts de clés étrangères, jointures.	Les relations sont représentées à l'aide de collections.

Cassandra est accessible en utilisant cqlsh ainsi que des pilotes de différentes langues. Ce chapitre explique comment configurer les environnements cqlsh et java pour qu'ils fonctionnent avec Cassandra.

Configuration avant l'installation

Avant d'installer Cassandra dans un environnement Linux, nous devons configurer Linux en utilisant ssh(Enveloppe de protection). Suivez les étapes ci-dessous pour configurer l'environnement Linux.

Créer un utilisateur

Au début, il est recommandé de créer un utilisateur distinct pour Hadoop afin d'isoler le système de fichiers Hadoop du système de fichiers Unix. Suivez les étapes ci-dessous pour créer un utilisateur.

Ouvrez root à l'aide de la commande “su”.
Créez un utilisateur à partir du compte root à l'aide de la commande “useradd username”.
Vous pouvez maintenant ouvrir un compte utilisateur existant à l'aide de la commande “su username”.

Ouvrez le terminal Linux et tapez les commandes suivantes pour créer un utilisateur.

$ su
password:
# useradd hadoop
# passwd hadoop
New passwd:
Retype new passwd

Configuration SSH et génération de clé

La configuration SSH est requise pour effectuer différentes opérations sur un cluster, telles que le démarrage, l'arrêt et les opérations de shell de démon distribuées. Pour authentifier différents utilisateurs de Hadoop, il est nécessaire de fournir une paire de clés publique / privée pour un utilisateur Hadoop et de la partager avec différents utilisateurs.

Les commandes suivantes sont utilisées pour générer une paire clé / valeur à l'aide de SSH -

copiez les clés publiques du formulaire id_rsa.pub dans allowed_keys,
et fournir le propriétaire,
autorisations de lecture et d'écriture sur le fichier authorized_keys respectivement.

$ ssh-keygen -t rsa
$ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys $ chmod 0600 ~/.ssh/authorized_keys

Vérifiez ssh:

ssh localhost

Installer Java

Java est le prérequis principal pour Cassandra. Tout d'abord, vous devez vérifier l'existence de Java dans votre système à l'aide de la commande suivante -

$ java -version

Si tout fonctionne bien, il vous donnera la sortie suivante.

java version "1.7.0_71"
Java(TM) SE Runtime Environment (build 1.7.0_71-b13)
Java HotSpot(TM) Client VM (build 25.0-b02, mixed mode)

Si vous n'avez pas Java dans votre système, suivez les étapes ci-dessous pour installer Java.

Étape 1

Téléchargez java (JDK <dernière version> - X64.tar.gz) à partir du lien suivant :

Then jdk-7u71-linux-x64.tar.gz will be downloaded onto your system.

Étape 2

En général, vous trouverez le fichier java téléchargé dans le dossier Téléchargements. Vérifiez-le et extrayez lejdk-7u71-linux-x64.gz fichier à l'aide des commandes suivantes.

$ cd Downloads/
$ ls jdk-7u71-linux-x64.gz $ tar zxf jdk-7u71-linux-x64.gz
$ ls
jdk1.7.0_71 jdk-7u71-linux-x64.gz

Étape 3

Pour rendre Java disponible à tous les utilisateurs, vous devez le déplacer vers l'emplacement «/ usr / local /». Ouvrez root et saisissez les commandes suivantes.

$ su
password:
# mv jdk1.7.0_71 /usr/local/
# exit

Étape 4

Pour la mise en place PATH et JAVA_HOME variables, ajoutez les commandes suivantes à ~/.bashrc fichier.

export JAVA_HOME = /usr/local/jdk1.7.0_71
export PATH = $PATH:$JAVA_HOME/bin

Appliquez maintenant toutes les modifications dans le système en cours d'exécution.

$ source ~/.bashrc

Étape 5

Utilisez les commandes suivantes pour configurer des alternatives Java.

# alternatives --install /usr/bin/java java usr/local/java/bin/java 2
# alternatives --install /usr/bin/javac javac usr/local/java/bin/javac 2
# alternatives --install /usr/bin/jar jar usr/local/java/bin/jar 2

# alternatives --set java usr/local/java/bin/java
# alternatives --set javac usr/local/java/bin/javac
# alternatives --set jar usr/local/java/bin/jar

Maintenant, utilisez le java -version commande depuis le terminal comme expliqué ci-dessus.

Tracer le chemin

Définissez le chemin du chemin Cassandra dans «/.bashrc» comme indiqué ci-dessous.

[hadoop@linux ~]$ gedit ~/.bashrc

export CASSANDRA_HOME = ~/cassandra
export PATH = $PATH:$CASSANDRA_HOME/bin

Télécharger Cassandra

Apache Cassandra est disponible sur Download Link Cassandra à l'aide de la commande suivante.

$ wget http://supergsego.com/apache/cassandra/2.1.2/apache-cassandra-2.1.2-bin.tar.gz

Décompressez Cassandra à l'aide de la commande zxvf comme indiqué ci-dessous.

$ tar zxvf apache-cassandra-2.1.2-bin.tar.gz.

Créez un nouveau répertoire nommé cassandra et déplacez-y le contenu du fichier téléchargé comme indiqué ci-dessous.

$ mkdir Cassandra $ mv apache-cassandra-2.1.2/* cassandra.

Configurer Cassandra

Ouvrez le cassandra.yaml: fichier, qui sera disponible dans le bin annuaire de Cassandra.

$ gedit cassandra.yaml

Note - Si vous avez installé Cassandra à partir d'un package deb ou rpm, les fichiers de configuration seront situés dans /etc/cassandra annuaire de Cassandra.

La commande ci-dessus ouvre le cassandra.yamlfichier. Vérifiez les configurations suivantes. Par défaut, ces valeurs seront définies sur les répertoires spécifiés.

data_file_directories “/var/lib/cassandra/data”
commitlog_directory “/var/lib/cassandra/commitlog”
saved_caches_directory “/var/lib/cassandra/saved_caches”

Assurez-vous que ces répertoires existent et peuvent être écrits, comme indiqué ci-dessous.

Créer des répertoires

En tant que super-utilisateur, créez les deux répertoires /var/lib/cassandra et /var./log/cassandra dans lequel Cassandra écrit ses données.

[root@linux cassandra]# mkdir /var/lib/cassandra
[root@linux cassandra]# mkdir /var/log/cassandra

Accorder des autorisations aux dossiers

Donnez des autorisations de lecture-écriture aux dossiers nouvellement créés comme indiqué ci-dessous.

[root@linux /]# chmod 777 /var/lib/cassandra
[root@linux /]# chmod 777 /var/log/cassandra

Démarrer Cassandra

Pour démarrer Cassandra, ouvrez la fenêtre du terminal, accédez au répertoire de base / home de Cassandra, où vous avez décompressé Cassandra, et exécutez la commande suivante pour démarrer votre serveur Cassandra.

$ cd $CASSANDRA_HOME $./bin/cassandra -f

L'utilisation de l'option –f indique à Cassandra de rester au premier plan au lieu de s'exécuter en tant que processus d'arrière-plan. Si tout se passe bien, vous pouvez voir le serveur Cassandra démarrer.

Environnement de programmation

Pour configurer Cassandra par programmation, téléchargez les fichiers jar suivants -

slf4j-api-1.7.5.jar
cassandra-driver-core-2.0.2.jar
guava-16.0.1.jar
metrics-core-3.0.2.jar
netty-3.9.0.Final.jar

Placez-les dans un dossier séparé. Par exemple, nous téléchargeons ces fichiers JAR dans un dossier nommé“Cassandra_jars”.

Définissez le chemin d'accès aux classes pour ce dossier dans “.bashrc”fichier comme indiqué ci-dessous.

[hadoop@linux ~]$ gedit ~/.bashrc //Set the following class path in the .bashrc file. export CLASSPATH = $CLASSPATH:/home/hadoop/Cassandra_jars/*

Environnement Eclipse

Ouvrez Eclipse et créez un nouveau projet appelé Cassandra _Examples.

Faites un clic droit sur le projet, sélectionnez Build Path→Configure Build Path comme indiqué ci-dessous.

Cela ouvrira la fenêtre des propriétés. Sous l'onglet Bibliothèques, sélectionnezAdd External JARs. Accédez au répertoire dans lequel vous avez enregistré vos fichiers jar. Sélectionnez les cinq fichiers jar et cliquez sur OK comme indiqué ci-dessous.

Sous Bibliothèques référencées, vous pouvez voir tous les fichiers JAR requis ajoutés comme indiqué ci-dessous -

Dépendances de Maven

Vous trouverez ci-dessous le pom.xml pour créer un projet Cassandra à l'aide de maven.

<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"  
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <build>
      <sourceDirectory>src</sourceDirectory>
      <plugins>
         <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.1</version>
				
               <configuration>
                  <source>1.7</source>
                  <target>1.7</target>
               </configuration>
					
         </plugin>
      </plugins>
   </build> 

   <dependencies>
      <dependency>
         <groupId>org.slf4j</groupId>
         <artifactId>slf4j-api</artifactId>
         <version>1.7.5</version>
      </dependency>
 
      <dependency>
         <groupId>com.datastax.cassandra</groupId>
         <artifactId>cassandra-driver-core</artifactId>
         <version>2.0.2</version>
      </dependency>
 
      <dependency>
         <groupId>com.google.guava</groupId>
         <artifactId>guava</artifactId>
         <version>16.0.1</version>
      </dependency>
 
      <dependency>
         <groupId>com.codahale.metrics</groupId>
         <artifactId>metrics-core</artifactId>
         <version>3.0.2</version>
      </dependency>
 
      <dependency>
         <groupId>io.netty</groupId>
         <artifactId>netty</artifactId>
         <version>3.9.0.Final</version>
      </dependency>
   </dependencies>

</project>

Ce chapitre couvre toutes les classes importantes de Cassandra.

Grappe

Cette classe est le principal point d'entrée du pilote. Il appartient àcom.datastax.driver.core paquet.

Méthodes

S. Non.	Méthodes et description
1	Session connect() Il crée une nouvelle session sur le cluster actuel et l'initialise.
2	void close() Il est utilisé pour fermer l'instance de cluster.
3	static Cluster.Builder builder() Il est utilisé pour créer une nouvelle instance Cluster.Builder.

Cluster.Builder

Cette classe est utilisée pour instancier le Cluster.Builder classe.

Méthodes

S. Non	Méthodes et description
1	Cluster.Builder addContactPoint(String address) Cette méthode ajoute un point de contact au cluster.
2	Cluster build() Cette méthode crée le cluster avec les points de contact donnés.

Session

Cette interface contient les connexions au cluster Cassandra. En utilisant cette interface, vous pouvez exécuterCQLrequêtes. Il appartient àcom.datastax.driver.core paquet.

Méthodes

S. Non.	Méthodes et description
1	void close() Cette méthode est utilisée pour fermer l'instance de session actuelle.
2	ResultSet execute(Statement statement) Cette méthode est utilisée pour exécuter une requête. Il nécessite un objet instruction.
3	ResultSet execute(String query) Cette méthode est utilisée pour exécuter une requête. Il nécessite une requête sous la forme d'un objet String.
4	PreparedStatement prepare(RegularStatement statement) Cette méthode prépare la requête fournie. La requête doit être fournie sous la forme d'une déclaration.
5	PreparedStatement prepare(String query) Cette méthode prépare la requête fournie. La requête doit être fournie sous la forme d'une chaîne.

Ce chapitre présente le shell du langage de requête Cassandra et explique comment utiliser ses commandes.

Par défaut, Cassandra fournit un shell de langage de requête Cassandra (cqlsh)qui permet aux utilisateurs de communiquer avec lui. En utilisant ce shell, vous pouvez exécuterCassandra Query Language (CQL).

En utilisant cqlsh, vous pouvez

définir un schéma,
insérer des données, et
exécuter une requête.

Démarrage de cqlsh

Démarrez cqlsh à l'aide de la commande cqlshcomme indiqué ci-dessous. Il donne l'invite Cassandra cqlsh en sortie.

[hadoop@linux bin]$ cqlsh
Connected to Test Cluster at 127.0.0.1:9042.
[cqlsh 5.0.1 | Cassandra 2.1.2 | CQL spec 3.2.0 | Native protocol v3]
Use HELP for help.
cqlsh>

Cqlsh- Comme indiqué ci-dessus, cette commande est utilisée pour démarrer l'invite cqlsh. De plus, il prend également en charge quelques options supplémentaires. Le tableau suivant explique toutes les options decqlsh et leur utilisation.

Options	Usage
cqlsh - aide	Affiche des rubriques d'aide sur les options de cqlsh commandes.
cqlsh --version	Fournit la version du cqlsh que vous utilisez.
cqlsh --couleur	Indique au shell d'utiliser une sortie colorée.
cqlsh - débogage	Affiche des informations de débogage supplémentaires.
cqlsh --execute cql_statement	Indique au shell d'accepter et d'exécuter une commande CQL.
cqlsh --file = “file name”	Si vous utilisez cette option, Cassandra exécute la commande dans le fichier donné et se ferme.
cqlsh - sans couleur	Demande à Cassandra de ne pas utiliser de sortie colorée.
cqlsh -u “user name”	En utilisant cette option, vous pouvez authentifier un utilisateur. Le nom d'utilisateur par défaut est: cassandra.
cqlsh-p “pass word”	En utilisant cette option, vous pouvez authentifier un utilisateur avec un mot de passe. Le mot de passe par défaut est: cassandra.

Commandes Cqlsh

Cqlsh a quelques commandes qui permettent aux utilisateurs d'interagir avec lui. Les commandes sont répertoriées ci-dessous.

Commandes Shell documentées

Vous trouverez ci-dessous les commandes shell documentées par Cqlsh. Ce sont les commandes utilisées pour effectuer des tâches telles que l'affichage des rubriques d'aide, la sortie de cqlsh, la description, etc.

HELP - Affiche les rubriques d'aide pour toutes les commandes cqlsh.
CAPTURE - Capture la sortie d'une commande et l'ajoute à un fichier.
CONSISTENCY - Affiche le niveau de cohérence actuel ou définit un nouveau niveau de cohérence.
COPY - Copie les données vers et depuis Cassandra.
DESCRIBE - Décrit le cluster actuel de Cassandra et ses objets.
EXPAND - Développe la sortie d'une requête verticalement.
EXIT - En utilisant cette commande, vous pouvez terminer cqlsh.
PAGING - Active ou désactive la pagination des requêtes.
SHOW - Affiche les détails de la session cqlsh en cours, comme la version de Cassandra, l'hôte ou les hypothèses de type de données.
SOURCE - Exécute un fichier contenant des instructions CQL.
TRACING - Active ou désactive le suivi des demandes.

Commandes de définition de données CQL

CREATE KEYSPACE - Crée un KeySpace dans Cassandra.
USE - Se connecte à un KeySpace créé.
ALTER KEYSPACE - Modifie les propriétés d'un KeySpace.
DROP KEYSPACE - Supprime un KeySpace
CREATE TABLE - Crée une table dans un KeySpace.
ALTER TABLE - Modifie les propriétés de colonne d'une table.
DROP TABLE - Supprime une table.
TRUNCATE - Supprime toutes les données d'une table.
CREATE INDEX - Définit un nouvel index sur une seule colonne d'une table.
DROP INDEX - Supprime un index nommé.

Commandes de manipulation de données CQL

INSERT - Ajoute des colonnes pour une ligne dans une table.
UPDATE - Met à jour une colonne d'une ligne.
DELETE - Supprime les données d'une table.
BATCH - Exécute plusieurs instructions DML à la fois.

Clauses CQL

SELECT - Cette clause lit les données d'une table
WHERE - La clause where est utilisée avec select pour lire une donnée spécifique.
ORDERBY - La clause orderby est utilisée avec select pour lire une donnée spécifique dans un ordre spécifique.

Cassandra fournit des commandes shell documentées en plus des commandes CQL. Vous trouverez ci-dessous les commandes shell documentées par Cassandra.

Aidez-moi

La commande HELP affiche un synopsis et une brève description de toutes les commandes cqlsh. Vous trouverez ci-dessous l'utilisation de la commande help.

cqlsh> help

Documented shell commands:
===========================
CAPTURE COPY DESCRIBE EXPAND PAGING SOURCE
CONSISTENCY DESC EXIT HELP SHOW TRACING.

CQL help topics:
================
ALTER           CREATE_TABLE_OPTIONS       SELECT
ALTER_ADD       CREATE_TABLE_TYPES         SELECT_COLUMNFAMILY
ALTER_ALTER     CREATE_USER                SELECT_EXPR
ALTER_DROP      DELETE                     SELECT_LIMIT
ALTER_RENAME    DELETE_COLUMNS             SELECT_TABLE

Capturer

Cette commande capture la sortie d'une commande et l'ajoute à un fichier. Par exemple, jetez un œil au code suivant qui capture la sortie dans un fichier nomméOutputfile.

cqlsh> CAPTURE '/home/hadoop/CassandraProgs/Outputfile'

Lorsque nous tapons une commande dans le terminal, la sortie sera capturée par le fichier donné. Vous trouverez ci-dessous la commande utilisée et le cliché du fichier de sortie.

cqlsh:tutorialspoint> select * from emp;

Vous pouvez désactiver la capture à l'aide de la commande suivante.

cqlsh:tutorialspoint> capture off;

Cohérence

Cette commande affiche le niveau de cohérence actuel ou définit un nouveau niveau de cohérence.

cqlsh:tutorialspoint> CONSISTENCY
Current consistency level is 1.

Copie

Cette commande copie les données vers et depuis Cassandra dans un fichier. Ci-dessous est un exemple pour copier la table nomméeemp au dossier myfile.

cqlsh:tutorialspoint> COPY emp (emp_id, emp_city, emp_name, emp_phone,emp_sal) TO ‘myfile’;
4 rows exported in 0.034 seconds.

Si vous ouvrez et vérifiez le fichier fourni, vous pouvez trouver les données copiées comme indiqué ci-dessous.

Décris

Cette commande décrit le cluster actuel de Cassandra et ses objets. Les variantes de cette commande sont expliquées ci-dessous.

Describe cluster - Cette commande fournit des informations sur le cluster.

cqlsh:tutorialspoint> describe cluster;

Cluster: Test Cluster
Partitioner: Murmur3Partitioner

Range ownership:
                  -658380912249644557 [127.0.0.1]
                  -2833890865268921414 [127.0.0.1]
                  -6792159006375935836 [127.0.0.1]

Describe Keyspaces- Cette commande répertorie tous les espaces de clés d'un cluster. Vous trouverez ci-dessous l'utilisation de cette commande.

cqlsh:tutorialspoint> describe keyspaces;

system_traces system tp tutorialspoint

Describe tables- Cette commande répertorie toutes les tables d'un espace de clés. Vous trouverez ci-dessous l'utilisation de cette commande.

cqlsh:tutorialspoint> describe tables;
emp

Describe table- Cette commande fournit la description d'une table. Vous trouverez ci-dessous l'utilisation de cette commande.

cqlsh:tutorialspoint> describe table emp;

CREATE TABLE tutorialspoint.emp (
   emp_id int PRIMARY KEY,
   emp_city text,
   emp_name text,
   emp_phone varint,
   emp_sal varint
) WITH bloom_filter_fp_chance = 0.01
   AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}'
   AND comment = ''
   AND compaction = {'min_threshold': '4', 'class':
   'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy',
   'max_threshold': '32'}
	
   AND compression = {'sstable_compression':
   'org.apache.cassandra.io.compress.LZ4Compressor'}
	
   AND dclocal_read_repair_chance = 0.1
   AND default_time_to_live = 0
   AND gc_grace_seconds = 864000
   AND max_index_interval = 2048
   AND memtable_flush_period_in_ms = 0
   AND min_index_interval = 128
   AND read_repair_chance = 0.0
   AND speculative_retry = '99.0PERCENTILE';
CREATE INDEX emp_emp_sal_idx ON tutorialspoint.emp (emp_sal);

Décrivez le type

Cette commande est utilisée pour décrire un type de données défini par l'utilisateur. Vous trouverez ci-dessous l'utilisation de cette commande.

cqlsh:tutorialspoint> describe type card_details;

CREATE TYPE tutorialspoint.card_details (
   num int,
   pin int,
   name text,
   cvv int,
   phone set<int>,
   mail text
);

Décrire les types

Cette commande répertorie tous les types de données définis par l'utilisateur. Vous trouverez ci-dessous l'utilisation de cette commande. Supposons qu'il existe deux types de données définis par l'utilisateur:card et card_details.

cqlsh:tutorialspoint> DESCRIBE TYPES;

card_details card

Développer

Cette commande est utilisée pour développer la sortie. Avant d'utiliser cette commande, vous devez activer la commande d'expansion. Vous trouverez ci-dessous l'utilisation de cette commande.

cqlsh:tutorialspoint> expand on;
cqlsh:tutorialspoint> select * from emp;

@ Row 1
-----------+------------
    emp_id | 1
  emp_city | Hyderabad
  emp_name | ram
 emp_phone | 9848022338
   emp_sal | 50000
  
@ Row 2
-----------+------------
    emp_id | 2
  emp_city | Delhi
  emp_name | robin
 emp_phone | 9848022339
   emp_sal | 50000
  
@ Row 3
-----------+------------
    emp_id | 4
  emp_city | Pune
  emp_name | rajeev
 emp_phone | 9848022331
   emp_sal | 30000
  
@ Row 4
-----------+------------
    emp_id | 3
  emp_city | Chennai
  emp_name | rahman
 emp_phone | 9848022330
   emp_sal | 50000
(4 rows)

Note - Vous pouvez désactiver l'option d'extension à l'aide de la commande suivante.

cqlsh:tutorialspoint> expand off;
Disabled Expanded output.

Sortie

Cette commande est utilisée pour terminer le shell cql.

Spectacle

Cette commande affiche les détails de la session cqlsh en cours, comme la version de Cassandra, l'hôte ou les hypothèses de type de données. Vous trouverez ci-dessous l'utilisation de cette commande.

cqlsh:tutorialspoint> show host;
Connected to Test Cluster at 127.0.0.1:9042.

cqlsh:tutorialspoint> show version;
[cqlsh 5.0.1 | Cassandra 2.1.2 | CQL spec 3.2.0 | Native protocol v3]

La source

En utilisant cette commande, vous pouvez exécuter les commandes dans un fichier. Supposons que notre fichier d'entrée soit le suivant -

Ensuite, vous pouvez exécuter le fichier contenant les commandes comme indiqué ci-dessous.

cqlsh:tutorialspoint> source '/home/hadoop/CassandraProgs/inputfile';

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad |   ram    | 9848022338 | 50000
      2 | Delhi     |   robin  | 9848022339 | 50000
      3 | Pune      |   rajeev | 9848022331 | 30000
      4 | Chennai   |   rahman | 9848022330 | 50000
(4 rows)

Création d'un Keyspace à l'aide de Cqlsh

Un espace de clés dans Cassandra est un espace de noms qui définit la réplication de données sur les nœuds. Un cluster contient un espace de clés par nœud. Vous trouverez ci-dessous la syntaxe pour créer un espace de clés à l'aide de l'instructionCREATE KEYSPACE.

Syntaxe

CREATE KEYSPACE <identifier> WITH <properties>

c'est à dire

CREATE KEYSPACE “KeySpace Name”
WITH replication = {'class': ‘Strategy name’, 'replication_factor' : ‘No.Of   replicas’};

CREATE KEYSPACE “KeySpace Name”
WITH replication = {'class': ‘Strategy name’, 'replication_factor' : ‘No.Of  replicas’}

AND durable_writes = ‘Boolean value’;

L'instruction CREATE KEYSPACE a deux propriétés: replication et durable_writes.

Réplication

L'option de réplication consiste à spécifier le Replica Placement strategyet le nombre de répliques voulues. Le tableau suivant répertorie toutes les stratégies de placement de réplique.

Nom de la stratégie	La description
Simple Strategy'	Spécifie un facteur de réplication simple pour le cluster.
Network Topology Strategy	En utilisant cette option, vous pouvez définir le facteur de réplication pour chaque centre de données indépendamment.
Old Network Topology Strategy	Il s'agit d'une stratégie de réplication héritée.

En utilisant cette option, vous pouvez indiquer à Cassandra s'il faut utiliser commitlogpour les mises à jour sur le KeySpace actuel. Cette option n'est pas obligatoire et par défaut, elle est définie sur true.

Example

Given below is an example of creating a KeySpace.

Here we are creating a KeySpace named TutorialsPoint.
We are using the first replica placement strategy, i.e.., Simple Strategy.
And we are choosing the replication factor to 1 replica.

cqlsh.> CREATE KEYSPACE tutorialspoint
WITH replication = {'class':'SimpleStrategy', 'replication_factor' : 3};

Verification

You can verify whether the table is created or not using the command Describe. If you use this command over keyspaces, it will display all the keyspaces created as shown below.

cqlsh> DESCRIBE keyspaces;

tutorialspoint system system_traces

Here you can observe the newly created KeySpace tutorialspoint.

Durable_writes

By default, the durable_writes properties of a table is set to true, however it can be set to false. You cannot set this property to simplex strategy.

Example

Given below is the example demonstrating the usage of durable writes property.

cqlsh> CREATE KEYSPACE test
... WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3 }
... AND DURABLE_WRITES = false;

Verification

You can verify whether the durable_writes property of test KeySpace was set to false by querying the System Keyspace. This query gives you all the KeySpaces along with their properties.

cqlsh> SELECT * FROM system_schema.keyspaces;

  keyspace_name | durable_writes |                                       strategy_class | strategy_options
----------------+----------------+------------------------------------------------------+----------------------------

           test |          False | org.apache.cassandra.locator.NetworkTopologyStrategy | {"datacenter1" : "3"}

 tutorialspoint |           True |          org.apache.cassandra.locator.SimpleStrategy | {"replication_factor" : "4"}

         system |           True |           org.apache.cassandra.locator.LocalStrategy | { }

  system_traces |           True |          org.apache.cassandra.locator.SimpleStrategy | {"replication_factor" : "2"}

(4 rows)

Here you can observe the durable_writes property of test KeySpace was set to false.

Using a Keyspace

You can use a created KeySpace using the keyword USE. Its syntax is as follows −

Syntax:USE <identifier>

Example

In the following example, we are using the KeySpace tutorialspoint.

cqlsh> USE tutorialspoint;
cqlsh:tutorialspoint>

Creating a Keyspace using Java API

You can create a Keyspace using the execute() method of Session class. Follow the steps given below to create a keyspace using Java API.

Step1: Create a Cluster Object

First of all, create an instance of Cluster.builder class of com.datastax.driver.core package as shown below.

//Creating Cluster.Builder object

Cluster.Builder builder1 = Cluster.builder();

Add a contact point (IP address of the node) using addContactPoint() method of Cluster.Builder object. This method returns Cluster.Builder.

//Adding contact point to the Cluster.Builder object

Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

Using the new builder object, create a cluster object. To do so, you have a method called build() in the Cluster.Builder class. The following code shows how to create a cluster object.

//Building a cluster
Cluster cluster = builder.build();

You can build a cluster object in a single line of code as shown below.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Step 2: Create a Session Object

Create an instance of Session object using the connect() method of Cluster class as shown below.

Session session = cluster.connect( );

This method creates a new session and initializes it. If you already have a keyspace, you can set it to the existing one by passing the keyspace name in string format to this method as shown below.

Session session = cluster.connect(“ Your keyspace name ” );

Step 3: Execute Query

You can execute CQL queries using the execute() method of Session class. Pass the query either in string format or as a Statement class object to the execute() method. Whatever you pass to this method in string format will be executed on the cqlsh.

In this example, we are creating a KeySpace named tp. We are using the first replica placement strategy, i.e., Simple Strategy, and we are choosing the replication factor to 1 replica.

You have to store the query in a string variable and pass it to the execute() method as shown below.

String query = "CREATE KEYSPACE tp WITH replication "
   + "= {'class':'SimpleStrategy', 'replication_factor':1}; ";
session.execute(query);

Step4 : Use the KeySpace

You can use a created KeySpace using the execute() method as shown below.

execute(“ USE tp ” );

Given below is the complete program to create and use a keyspace in Cassandra using Java API.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Create_KeySpace {

   public static void main(String args[]){

      //Query
      String query = "CREATE KEYSPACE tp WITH replication "
         + "= {'class':'SimpleStrategy', 'replication_factor':1};";
                    
      //creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
    
      //Creating Session object
      Session session = cluster.connect();
     
      //Executing the query
      session.execute(query);
     
      //using the KeySpace
      session.execute("USE tp");
      System.out.println("Keyspace created"); 
   }
}

Save the above program with the class name followed by .java, browse to the location where it is saved. Compile and execute the program as shown below.

$javac Create_KeySpace.java
$java Create_KeySpace

Under normal conditions, it will produce the following output −

Keyspace created

Altering a KeySpace

ALTER KEYSPACE can be used to alter properties such as the number of replicas and the durable_writes of a KeySpace. Given below is the syntax of this command.

Syntax

ALTER KEYSPACE <identifier> WITH <properties>

i.e.

ALTER KEYSPACE “KeySpace Name”
WITH replication = {'class': ‘Strategy name’, 'replication_factor' : ‘No.Of  replicas’};

The properties of ALTER KEYSPACE are same as CREATE KEYSPACE. It has two properties: replication and durable_writes.

Replication

The replication option specifies the replica placement strategy and the number of replicas wanted.

Durable_writes

Using this option, you can instruct Cassandra whether to use commitlog for updates on the current KeySpace. This option is not mandatory and by default, it is set to true.

Example

Given below is an example of altering a KeySpace.

Here we are altering a KeySpace named TutorialsPoint.
We are changing the replication factor from 1 to 3.

cqlsh.> ALTER KEYSPACE tutorialspoint
WITH replication = {'class':'NetworkTopologyStrategy', 'replication_factor' : 3};

Modification des écritures durables

Vous pouvez également modifier la propriété durable_writes d'un KeySpace. Ci-dessous, la propriété durable_writes dutest KeySpace.

SELECT * FROM system_schema.keyspaces;

  keyspace_name | durable_writes |                                       strategy_class | strategy_options
----------------+----------------+------------------------------------------------------+----------------------------
           test |          False | org.apache.cassandra.locator.NetworkTopologyStrategy | {"datacenter1":"3"}

 tutorialspoint |           True |          org.apache.cassandra.locator.SimpleStrategy | {"replication_factor":"4"}

         system |           True |           org.apache.cassandra.locator.LocalStrategy | { }

  system_traces |           True |          org.apache.cassandra.locator.SimpleStrategy | {"replication_factor":"2"}
(4 rows)

ALTER KEYSPACE test
WITH REPLICATION = {'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3}
AND DURABLE_WRITES = true;

Encore une fois, si vous vérifiez les propriétés de KeySpaces, il produira la sortie suivante.

SELECT * FROM system_schema.keyspaces;
  keyspace_name | durable_writes |                                       strategy_class | strategy_options
----------------+----------------+------------------------------------------------------+----------------------------
           test |           True | org.apache.cassandra.locator.NetworkTopologyStrategy | {"datacenter1":"3"}

 tutorialspoint |           True |          org.apache.cassandra.locator.SimpleStrategy | {"replication_factor":"4"}

         system |           True |           org.apache.cassandra.locator.LocalStrategy | { }

  system_traces |           True |          org.apache.cassandra.locator.SimpleStrategy | {"replication_factor":"2"}

(4 rows)

Modification d'un espace clé à l'aide de l'API Java

Vous pouvez modifier un espace de clés en utilisant le execute() méthode de Sessionclasse. Suivez les étapes ci-dessous pour modifier un espace de clés à l'aide de l'API Java

Étape 1: créer un objet de cluster

Tout d'abord, créez une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

À l'aide du nouvel objet de générateur, créez un objet de cluster. Pour ce faire, vous disposez d'une méthode appeléebuild() dans le Cluster.Builderclasse. Le code suivant montre comment créer un objet de cluster.

//Building a cluster

Cluster cluster = builder.build();

Vous pouvez créer l'objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créer une instance de Session objet utilisant le connect() méthode de Clusterclasse comme indiqué ci-dessous.

Session session = cluster.connect( );

Cette méthode crée une nouvelle session et l'initialise. Si vous avez déjà un espace de clés, vous pouvez le définir sur celui existant en transmettant le nom de l'espace de clés au format chaîne à cette méthode, comme indiqué ci-dessous.

Session session = cluster.connect(“ Your keyspace name ” );

Étape 3: Exécuter la requête

Vous pouvez exécuter des requêtes CQL en utilisant la méthode execute () de la classe Session. Transmettez la requête au format chaîne ou enStatementobjet de classe à la méthode execute (). Tout ce que vous passez à cette méthode au format chaîne sera exécuté sur lecqlsh.

Dans cet exemple,

Nous modifions un espace de clés nommé tp. Nous modifions l'option de réplication de la stratégie simple à la stratégie de topologie de réseau.
Nous modifions le durable_writes à faux

Vous devez stocker la requête dans une variable chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous.

//Query
String query = "ALTER KEYSPACE tp WITH replication " + "=   {'class':'NetworkTopologyStrategy', 'datacenter1':3}" +" AND DURABLE_WRITES = false;";
session.execute(query);

Vous trouverez ci-dessous le programme complet pour créer et utiliser un espace de clés dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Alter_KeySpace {
   public static void main(String args[]){

      //Query
      String query = "ALTER KEYSPACE tp WITH replication " + "= {'class':'NetworkTopologyStrategy', 'datacenter1':3}"
         + "AND DURABLE_WRITES = false;";

      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
   
      //Creating Session object
      Session session = cluster.connect();
 
      //Executing the query
      session.execute(query);
 
      System.out.println("Keyspace altered");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Alter_KeySpace.java
$java Alter_KeySpace

Dans des conditions normales, il produit la sortie suivante -

Keyspace Altered

Déposer un espace clé

Vous pouvez supprimer un KeySpace à l'aide de la commande DROP KEYSPACE. Vous trouverez ci-dessous la syntaxe pour supprimer un KeySpace.

Syntaxe

DROP KEYSPACE <identifier>

c'est à dire

DROP KEYSPACE “KeySpace name”

Exemple

Le code suivant supprime l'espace de clés tutorialspoint.

cqlsh> DROP KEYSPACE tutorialspoint;

Vérification

Vérifiez les espaces de clés à l'aide de la commande Describe et vérifiez si la table est supprimée comme indiqué ci-dessous.

cqlsh> DESCRIBE keyspaces;

system system_traces

Puisque nous avons supprimé le point du didacticiel de l'espace de clés, vous ne le trouverez pas dans la liste des espaces de clés.

Suppression d'un espace clé à l'aide de l'API Java

Vous pouvez créer un espace de clés en utilisant la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour supprimer un espace de clés à l'aide de l'API Java.

Étape 1: créer un objet de cluster

Tout d'abord, créez une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object 
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer un objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“ Your keyspace name”);

Étape 3: Exécuter la requête

Vous pouvez exécuter des requêtes CQL en utilisant la méthode execute () de la classe Session. Transmettez la requête au format chaîne ou en tant qu'objet de classe Statement à la méthode execute (). Tout ce que vous passez à cette méthode au format chaîne sera exécuté sur le cqlsh.

Dans l'exemple suivant, nous supprimons un espace de clés nommé tp. Vous devez stocker la requête dans une variable chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous.

String query = "DROP KEYSPACE tp; ";

session.execute(query);

Vous trouverez ci-dessous le programme complet pour créer et utiliser un espace de clés dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Drop_KeySpace {

   public static void main(String args[]){

      //Query
      String query = "Drop KEYSPACE tp";

      //creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
    
      //Creating Session object
      Session session = cluster.connect();
    
      //Executing the query
      session.execute(query);
      System.out.println("Keyspace deleted");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Delete_KeySpace.java
$java Delete_KeySpace

Dans des conditions normales, il devrait produire la sortie suivante -

Keyspace deleted

Créer une table

Vous pouvez créer une table à l'aide de la commande CREATE TABLE. Vous trouverez ci-dessous la syntaxe pour créer une table.

Syntaxe

CREATE (TABLE | COLUMNFAMILY) <tablename>
('<column-definition>' , '<column-definition>')
(WITH <option> AND <option>)

Définition d'une colonne

Vous pouvez définir une colonne comme indiqué ci-dessous.

column name1 data type,
column name2 data type,

example:

age int,
name text

Clé primaire

La clé primaire est une colonne utilisée pour identifier de manière unique une ligne. Par conséquent, la définition d'une clé primaire est obligatoire lors de la création d'une table. Une clé primaire est constituée d'une ou plusieurs colonnes d'une table. Vous pouvez définir une clé primaire d'une table comme indiqué ci-dessous.

CREATE TABLE tablename(
   column1 name datatype PRIMARYKEY,
   column2 name data type,
   column3 name data type.
   )

CREATE TABLE tablename(
   column1 name datatype PRIMARYKEY,
   column2 name data type,
   column3 name data type,
   PRIMARY KEY (column1)
   )

Exemple

Vous trouverez ci-dessous un exemple pour créer une table dans Cassandra à l'aide de cqlsh. Nous voici -

Utilisation du point du didacticiel de l'espace de clés
Créer une table nommée emp

Il contiendra des détails tels que le nom de l'employé, l'identifiant, la ville, le salaire et le numéro de téléphone. L'identifiant d'employé est la clé primaire.

cqlsh> USE tutorialspoint;
cqlsh:tutorialspoint>; CREATE TABLE emp(
   emp_id int PRIMARY KEY,
   emp_name text,
   emp_city text,
   emp_sal varint,
   emp_phone varint
   );

Vérification

L'instruction select vous donnera le schéma. Vérifiez le tableau à l'aide de l'instruction select comme indiqué ci-dessous.

cqlsh:tutorialspoint> select * from emp;

 emp_id | emp_city | emp_name | emp_phone | emp_sal
--------+----------+----------+-----------+---------

(0 rows)

Ici vous pouvez observer le tableau créé avec les colonnes données. Puisque nous avons supprimé le point du didacticiel de l'espace de clés, vous ne le trouverez pas dans la liste des espaces de clés.

Création d'une table à l'aide de l'API Java

Vous pouvez créer une table en utilisant la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour créer une table à l'aide de l'API Java.

Étape 1: créer un objet de cluster

Tout d'abord, créez une instance du Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer un objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide du connect() méthode de Cluster classe comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“ Your keyspace name ” );

Ici, nous utilisons l'espace de clés nommé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“ tp” );

Étape 3: Exécuter la requête

Dans l'exemple suivant, nous créons une table nommée emp. Vous devez stocker la requête dans une variable chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous.

//Query
String query = "CREATE TABLE emp(emp_id int PRIMARY KEY, "
   + "emp_name text, "
   + "emp_city text, "
   + "emp_sal varint, "
   + "emp_phone varint );";
session.execute(query);

Vous trouverez ci-dessous le programme complet pour créer et utiliser un espace de clés dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Create_Table {

   public static void main(String args[]){

      //Query
      String query = "CREATE TABLE emp(emp_id int PRIMARY KEY, "
         + "emp_name text, "
         + "emp_city text, "
         + "emp_sal varint, "
         + "emp_phone varint );";
		
      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
   
      //Creating Session object
      Session session = cluster.connect("tp");
 
      //Executing the query
      session.execute(query);
 
      System.out.println("Table created");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Create_Table.java
$java Create_Table

Dans des conditions normales, il devrait produire la sortie suivante -

Table created

Modifier une table

Vous pouvez modifier une table à l'aide de la commande ALTER TABLE. Vous trouverez ci-dessous la syntaxe pour créer une table.

Syntaxe

ALTER (TABLE | COLUMNFAMILY) <tablename> <instruction>

À l'aide de la commande ALTER, vous pouvez effectuer les opérations suivantes -

Ajouter une colonne
Déposer une colonne

Ajouter une colonne

À l'aide de la commande ALTER, vous pouvez ajouter une colonne à une table. Lors de l'ajout de colonnes, vous devez vous assurer que le nom de la colonne n'est pas en conflit avec les noms de colonne existants et que la table n'est pas définie avec l'option de stockage compact. Vous trouverez ci-dessous la syntaxe pour ajouter une colonne à une table.

ALTER TABLE table name
ADD  new column datatype;

Example

Vous trouverez ci-dessous un exemple pour ajouter une colonne à une table existante. Ici, nous ajoutons une colonne appeléeemp_email du type de données texte à la table nommée emp.

cqlsh:tutorialspoint> ALTER TABLE emp
   ... ADD emp_email text;

Verification

Utilisez l'instruction SELECT pour vérifier si la colonne est ajoutée ou non. Ici, vous pouvez observer la colonne emp_email nouvellement ajoutée.

cqlsh:tutorialspoint> select * from emp;

 emp_id | emp_city | emp_email | emp_name | emp_phone | emp_sal
--------+----------+-----------+----------+-----------+---------

Déposer une colonne

À l'aide de la commande ALTER, vous pouvez supprimer une colonne d'une table. Avant de supprimer une colonne d'une table, vérifiez que la table n'est pas définie avec l'option de stockage compact. Vous trouverez ci-dessous la syntaxe pour supprimer une colonne d'une table à l'aide de la commande ALTER.

ALTER table name
DROP column name;

Example

Vous trouverez ci-dessous un exemple pour supprimer une colonne d'une table. Ici, nous supprimons la colonne nomméeemp_email.

cqlsh:tutorialspoint> ALTER TABLE emp DROP emp_email;

Verification

Vérifiez si la colonne est supprimée à l'aide du select déclaration, comme indiqué ci-dessous.

cqlsh:tutorialspoint> select * from emp;

 emp_id | emp_city | emp_name | emp_phone | emp_sal
--------+----------+----------+-----------+---------
(0 rows)

Depuis emp_email la colonne a été supprimée, vous ne pouvez plus la trouver.

Modifier une table à l'aide de l'API Java

Vous pouvez créer une table en utilisant la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour modifier une table à l'aide de l'API Java.

Étape 1: créer un objet de cluster

Tout d'abord, créez une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer un objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Cette méthode crée une nouvelle session et l'initialise. Si vous avez déjà un espace de clés, vous pouvez le définir sur celui existant en transmettant le nom de l'espace de clé au format chaîne à cette méthode comme indiqué ci-dessous.

Session session = cluster.connect(“ Your keyspace name ” );
Session session = cluster.connect(“ tp” );

Ici, nous utilisons le KeySpace nommé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Étape 3: Exécuter la requête

Dans l'exemple suivant, nous ajoutons une colonne à une table nommée emp. Pour ce faire, vous devez stocker la requête dans une variable chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous.

//Query
String query1 = "ALTER TABLE emp ADD emp_email text";
session.execute(query);

Ci-dessous est le programme complet pour ajouter une colonne à une table existante.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Add_column {

   public static void main(String args[]){

      //Query
      String query = "ALTER TABLE emp ADD emp_email text";

      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
     
      //Creating Session object
      Session session = cluster.connect("tp");
    
      //Executing the query
      session.execute(query);
  
      System.out.println("Column added");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Add_Column.java
$java Add_Column

Dans des conditions normales, il devrait produire la sortie suivante -

Column added

Supprimer une colonne

Ci-dessous est le programme complet pour supprimer une colonne d'une table existante.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Delete_Column {

   public static void main(String args[]){

      //Query
      String query = "ALTER TABLE emp DROP emp_email;";

      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
 
      //Creating Session object
      Session session = cluster.connect("tp");
 
      //executing the query
      session.execute(query);
    
      System.out.println("Column deleted");
   }
 }

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Delete_Column.java
$java Delete_Column

Dans des conditions normales, il devrait produire la sortie suivante -

Column deleted

Déposer une table

Vous pouvez supprimer une table à l'aide de la commande Drop Table. Sa syntaxe est la suivante -

Syntaxe

DROP TABLE <tablename>

Exemple

Le code suivant supprime une table existante d'un KeySpace.

cqlsh:tutorialspoint> DROP TABLE emp;

Vérification

Utilisez la commande Décrire pour vérifier si la table est supprimée ou non. La table emp ayant été supprimée, vous ne la trouverez pas dans la liste des familles de colonnes.

cqlsh:tutorialspoint> DESCRIBE COLUMNFAMILIES;
employee

Suppression d'une table à l'aide de l'API Java

Vous pouvez supprimer une table en utilisant la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour supprimer une table à l'aide de l'API Java.

Étape 1: créer un objet de cluster

Tout d'abord, créez une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous -

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajouter un point de contact (adresse IP du nœud) en utilisant addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer un objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“Your keyspace name”);

Ici, nous utilisons l'espace de clés nommé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“tp”);

Étape 3: Exécuter la requête

Dans l'exemple suivant, nous supprimons une table nommée emp. Vous devez stocker la requête dans une variable chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous.

// Query

String query = "DROP TABLE emp1;”;
session.execute(query);

Vous trouverez ci-dessous le programme complet pour supprimer une table dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;
 
public class Drop_Table {

   public static void main(String args[]){

      //Query
      String query = "DROP TABLE emp1;";
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
    
      //Creating Session object
      Session session = cluster.connect("tp");
   
      //Executing the query
      session.execute(query);
    
      System.out.println("Table dropped");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Drop_Table.java
$java Drop_Table

Dans des conditions normales, il devrait produire la sortie suivante -

Table dropped

Tronquer une table

Vous pouvez tronquer une table à l'aide de la commande TRUNCATE. Lorsque vous tronquez une table, toutes les lignes de la table sont supprimées définitivement. Voici la syntaxe de cette commande.

Syntaxe

TRUNCATE <tablename>

Exemple

Supposons qu'il existe une table appelée student avec les données suivantes.

s_id	Le nom de	s_branch	s_aggregate
1	RAM	IL	70
2	rahman	EEE	75
3	robbin	Mech	72

Lorsque vous exécutez l'instruction select pour obtenir la table student, il vous donnera la sortie suivante.

cqlsh:tp> select * from student;

 s_id | s_aggregate | s_branch | s_name
------+-------------+----------+--------
    1 |          70 |       IT | ram
    2 |          75 |      EEE | rahman
    3 |          72 |     MECH | robbin

(3 rows)

Tronquez maintenant la table à l'aide de la commande TRUNCATE.

cqlsh:tp> TRUNCATE student;

Vérification

Vérifiez si la table est tronquée en exécutant le selectdéclaration. Vous trouverez ci-dessous la sortie de l'instruction select sur la table Student après la troncature.

cqlsh:tp> select * from student;

 s_id | s_aggregate | s_branch | s_name
------+-------------+----------+--------

(0 rows)

Tronquer une table à l'aide de l'API Java

Vous pouvez tronquer une table à l'aide de la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour tronquer un tableau.

Étape 1: créer un objet de cluster

Tout d'abord, créez une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer un objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: création d'un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Cette méthode crée une nouvelle session et l'initialise. Si vous disposez déjà d'un espace de clés, vous pouvez le définir sur celui existant en transmettant le nom de l'espace de clé au format chaîne à cette méthode, comme indiqué ci-dessous.

Session session = cluster.connect(“ Your keyspace name ” );
Session session = cluster.connect(“ tp” );

Ici, nous utilisons l'espace de clés nommé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Étape 3: Exécuter la requête

Dans l'exemple suivant, nous tronquons une table nommée emp. Vous devez stocker la requête dans une variable chaîne et la transmettre auexecute() méthode comme indiqué ci-dessous.

//Query
String query = "TRUNCATE emp;;”;
session.execute(query);

Vous trouverez ci-dessous le programme complet pour tronquer une table dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Truncate_Table {

   public static void main(String args[]){
   
      //Query
      String query = "Truncate student;";
   
      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
   
      //Creating Session object
      Session session = cluster.connect("tp");
   
      //Executing the query
      session.execute(query);
      System.out.println("Table truncated");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Truncate_Table.java
$java Truncate_Table

Dans des conditions normales, il devrait produire la sortie suivante -

Table truncated

Créer un index à l'aide de Cqlsh

Vous pouvez créer un index dans Cassandra à l'aide de la commande CREATE INDEX. Sa syntaxe est la suivante -

CREATE INDEX <identifier> ON <tablename>

Vous trouverez ci-dessous un exemple pour créer un index vers une colonne. Ici, nous créons un index vers une colonne 'emp_name' dans une table nommée emp.

cqlsh:tutorialspoint> CREATE INDEX name ON emp1 (emp_name);

Création d'un index à l'aide de l'API Java

Vous pouvez créer un index vers une colonne d'une table à l'aide de la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour créer un index vers une colonne dans une table.

Étape 1: créer un objet de cluster

Tout d'abord, créez une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer l'objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de Cluster classe comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“ Your keyspace name ” );

Ici, nous utilisons le KeySpace appelé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“ tp” );

Étape 3: Exécuter la requête

Dans l'exemple suivant, nous créons un index vers une colonne appelée emp_name, dans une table nommée emp. Vous devez stocker la requête dans une variable chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous.

//Query
String query = "CREATE INDEX name ON emp1 (emp_name);";
session.execute(query);

Vous trouverez ci-dessous le programme complet pour créer un index d'une colonne dans une table dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Create_Index {
 
   public static void main(String args[]){

      //Query
      String query = "CREATE INDEX name ON emp1 (emp_name);";
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
       
      //Creating Session object
      Session session = cluster.connect("tp");
 
      //Executing the query
      session.execute(query);
      System.out.println("Index created");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Create_Index.java
$java Create_Index

Dans des conditions normales, il devrait produire la sortie suivante -

Index created

Supprimer un index

Vous pouvez supprimer un index à l'aide de la commande DROP INDEX. Sa syntaxe est la suivante -

DROP INDEX <identifier>

Vous trouverez ci-dessous un exemple pour supprimer un index d'une colonne dans une table. Ici, nous supprimons l'index du nom de la colonne dans la table emp.

cqlsh:tp> drop index name;

Suppression d'un index à l'aide de l'API Java

Vous pouvez supprimer un index d'une table à l'aide de la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour supprimer un index d'une table.

Étape 1: créer un objet de cluster

Créer une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builder object. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer un objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“ Your keyspace name ” );

Ici, nous utilisons le KeySpace nommé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“ tp” );

Étape 3: Exécuter la requête

Dans l'exemple suivant, nous supprimons un index «nom» de emptable. Vous devez stocker la requête dans une variable chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous.

//Query
String query = "DROP INDEX user_name;";
session.execute(query);

Vous trouverez ci-dessous le programme complet pour supprimer un index dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Drop_Index {

   public static void main(String args[]){
     
      //Query
      String query = "DROP INDEX user_name;";
 
      //Creating cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();.
 
      //Creating Session object
      Session session = cluster.connect("tp"); 
 
      //Executing the query
      session.execute(query);
      
      System.out.println("Index dropped");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Drop_index.java
$java Drop_index

Dans des conditions normales, il devrait produire la sortie suivante -

Index dropped

Utilisation des instructions Batch

En utilisant BATCH,vous pouvez exécuter plusieurs instructions de modification (insérer, mettre à jour, supprimer) simultanément. Sa syntaxe est la suivante -

BEGIN BATCH
<insert-stmt>/ <update-stmt>/ <delete-stmt>
APPLY BATCH

Exemple

Supposons qu'il existe une table dans Cassandra appelée emp contenant les données suivantes -

emp_id	nom_emp	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	merle	Delhi	9848022339	50000
3	rahman	Chennai	9848022330	45 000

Dans cet exemple, nous allons effectuer les opérations suivantes -

Insérez une nouvelle ligne avec les détails suivants (4, rajeev, pune, 9848022331, 30000).
Mettez à jour le salaire de l'employé avec l'ID de ligne 3 à 50000.
Supprimer la ville de l'employé avec l'ID de ligne 2.

Pour effectuer les opérations ci-dessus en une seule fois, utilisez la commande BATCH suivante -

cqlsh:tutorialspoint> BEGIN BATCH
... INSERT INTO emp (emp_id, emp_city, emp_name, emp_phone, emp_sal) values(  4,'Pune','rajeev',9848022331, 30000);
... UPDATE emp SET emp_sal = 50000 WHERE emp_id =3;
... DELETE emp_city FROM emp WHERE emp_id = 2;
... APPLY BATCH;

Vérification

Après avoir apporté des modifications, vérifiez la table à l'aide de l'instruction SELECT. Il devrait produire la sortie suivante -

cqlsh:tutorialspoint> select * from emp;

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad | ram      | 9848022338 | 50000
      2 | null      | robin    | 9848022339 | 50000
      3 | Chennai   | rahman   | 9848022330 | 50000
      4 | Pune      | rajeev   | 9848022331 | 30000
    
(4 rows)

Ici, vous pouvez observer le tableau avec des données modifiées.

Instructions par lots à l'aide de l'API Java

Les instructions Batch peuvent être écrites par programme dans une table à l'aide de la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour exécuter plusieurs instructions à l'aide d'une instruction batch à l'aide de l'API Java.

Étape 1: créer un objet de cluster

Créer une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

À l'aide du nouvel objet de générateur, créez un objet de cluster. Pour ce faire, vous disposez d'une méthode appeléebuild() dans le Cluster.Builderclasse. Utilisez le code suivant pour créer l'objet de cluster -

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer l'objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“ Your keyspace name ”);

Ici, nous utilisons le KeySpace nommé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“tp”);

Étape 3: Exécuter la requête

Dans cet exemple, nous allons effectuer les opérations suivantes -

Insérez une nouvelle ligne avec les détails suivants (4, rajeev, pune, 9848022331, 30000).
Mettez à jour le salaire de l'employé avec l'ID de ligne 3 à 50000.
Supprimez la ville de l'employé avec l'ID de ligne 2.

Vous devez stocker la requête dans une variable chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous.

String query1 = ” BEGIN BATCH INSERT INTO emp (emp_id, emp_city, emp_name,   emp_phone, emp_sal) values( 4,'Pune','rajeev',9848022331, 30000);
UPDATE emp SET emp_sal = 50000 WHERE emp_id =3;
DELETE emp_city FROM emp WHERE emp_id = 2;
APPLY BATCH;”;

Vous trouverez ci-dessous le programme complet pour exécuter plusieurs instructions simultanément sur une table dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Batch {

   public static void main(String args[]){
    
      //query
      String query =" BEGIN BATCH INSERT INTO emp (emp_id, emp_city,
         emp_name, emp_phone, emp_sal) values( 4,'Pune','rajeev',9848022331, 30000);"
    
         + "UPDATE emp SET emp_sal = 50000 WHERE emp_id =3;"
         + "DELETE emp_city FROM emp WHERE emp_id = 2;"
         + "APPLY BATCH;";

      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
 
      //Creating Session object
      Session session = cluster.connect("tp");
 
      //Executing the query
      session.execute(query);

      System.out.println("Changes done");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Batch.java
$java Batch

Dans des conditions normales, il devrait produire la sortie suivante -

Changes done

Création de données dans une table

Vous pouvez insérer des données dans les colonnes d'une ligne d'un tableau à l'aide de la commande INSERT. Vous trouverez ci-dessous la syntaxe pour créer des données dans une table.

INSERT INTO <tablename>
(<column1 name>, <column2 name>....)
VALUES (<value1>, <value2>....)
USING <option>

Exemple

Supposons qu'il existe une table appelée emp avec des colonnes (emp_id, emp_name, emp_city, emp_phone, emp_sal) et vous devez insérer les données suivantes dans le emp table.

emp_id	nom_emp	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	merle	Hyderabad	9848022339	40000
3	rahman	Chennai	9848022330	45 000

Utilisez les commandes ci-dessous pour remplir le tableau avec les données requises.

cqlsh:tutorialspoint> INSERT INTO emp (emp_id, emp_name, emp_city,
   emp_phone, emp_sal) VALUES(1,'ram', 'Hyderabad', 9848022338, 50000);

cqlsh:tutorialspoint> INSERT INTO emp (emp_id, emp_name, emp_city,
   emp_phone, emp_sal) VALUES(2,'robin', 'Hyderabad', 9848022339, 40000);

cqlsh:tutorialspoint> INSERT INTO emp (emp_id, emp_name, emp_city,
   emp_phone, emp_sal) VALUES(3,'rahman', 'Chennai', 9848022330, 45000);

Vérification

Après avoir inséré des données, utilisez l'instruction SELECT pour vérifier si les données ont été insérées ou non. Si vous vérifiez la table emp à l'aide de l'instruction SELECT, elle vous donnera la sortie suivante.

cqlsh:tutorialspoint> SELECT * FROM emp;

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad |      ram | 9848022338 | 50000
      2 | Hyderabad |    robin | 9848022339 | 40000
      3 |   Chennai |   rahman | 9848022330 | 45000
 
(3 rows)

Ici, vous pouvez observer que le tableau a rempli les données que nous avons insérées.

Création de données à l'aide de l'API Java

Vous pouvez créer des données dans une table à l'aide de la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour créer des données dans une table à l'aide de l'API java.

Étape 1: créer un objet de cluster

Créer une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint("127.0.0.1");

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer un objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“ Your keyspace name ” );

Ici, nous utilisons le KeySpace appelé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“ tp” );

Étape 3: Exécuter la requête

Dans l'exemple suivant, nous insérons des données dans une table appelée emp. Vous devez stocker la requête dans une variable chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous.

String query1 = “INSERT INTO emp (emp_id, emp_name, emp_city, emp_phone, emp_sal)
   VALUES(1,'ram', 'Hyderabad', 9848022338, 50000);” ;
 
String query2 = “INSERT INTO emp (emp_id, emp_name, emp_city, emp_phone, emp_sal)
   VALUES(2,'robin', 'Hyderabad', 9848022339, 40000);” ;
 
String query3 = “INSERT INTO emp (emp_id, emp_name, emp_city, emp_phone, emp_sal)
   VALUES(3,'rahman', 'Chennai', 9848022330, 45000);” ;
 
session.execute(query1);
session.execute(query2);
session.execute(query3);

Vous trouverez ci-dessous le programme complet pour insérer des données dans une table dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Create_Data {

   public static void main(String args[]){

      //queries
      String query1 = "INSERT INTO emp (emp_id, emp_name, emp_city, emp_phone,  emp_sal)"
		
         + " VALUES(1,'ram', 'Hyderabad', 9848022338, 50000);" ;
                             
      String query2 = "INSERT INTO emp (emp_id, emp_name, emp_city,
         emp_phone, emp_sal)"
      
         + " VALUES(2,'robin', 'Hyderabad', 9848022339, 40000);" ;
                             
      String query3 = "INSERT INTO emp (emp_id, emp_name, emp_city, emp_phone, emp_sal)"
       
         + " VALUES(3,'rahman', 'Chennai', 9848022330, 45000);" ;

      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
 
      //Creating Session object
      Session session = cluster.connect("tp");
       
      //Executing the query
      session.execute(query1);
        
      session.execute(query2);
        
      session.execute(query3);
        
      System.out.println("Data created");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Create_Data.java
$java Create_Data

Dans des conditions normales, il devrait produire la sortie suivante -

Data created

Mise à jour des données dans une table

UPDATEest la commande utilisée pour mettre à jour les données dans une table. Les mots-clés suivants sont utilisés lors de la mise à jour des données dans une table -

Where - Cette clause permet de sélectionner la ligne à mettre à jour.
Set - Définissez la valeur à l'aide de ce mot-clé.
Must - Comprend toutes les colonnes composant la clé primaire.

Lors de la mise à jour des lignes, si une ligne donnée n'est pas disponible, UPDATE crée une nouvelle ligne. Vous trouverez ci-dessous la syntaxe de la commande UPDATE -

UPDATE <tablename>
SET <column name> = <new value>
<column name> = <value>....
WHERE <condition>

Exemple

Supposons qu'il existe une table nommée emp. Ce tableau stocke les détails des employés d'une certaine entreprise et contient les détails suivants:

emp_id	nom_emp	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	merle	Hyderabad	9848022339	40000
3	rahman	Chennai	9848022330	45 000

Laissez-nous maintenant mettre à jour emp_city de robin à Delhi, et son salaire à 50000. Ci-dessous est la requête pour effectuer les mises à jour requises.

cqlsh:tutorialspoint> UPDATE emp SET emp_city='Delhi',emp_sal=50000
   WHERE emp_id=2;

Vérification

Utilisez l'instruction SELECT pour vérifier si les données ont été mises à jour ou non. Si vous vérifiez la table emp à l'aide de l'instruction SELECT, elle produira la sortie suivante.

cqlsh:tutorialspoint> select * from emp;

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad |      ram | 9848022338 | 50000
      2 |     Delhi |    robin | 9848022339 | 50000
      3 |   Chennai |   rahman | 9848022330 | 45000
      
(3 rows)

Ici, vous pouvez observer que les données de la table ont été mises à jour.

Mise à jour des données à l'aide de l'API Java

Vous pouvez mettre à jour les données d'une table à l'aide de la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour mettre à jour les données dans une table à l'aide de l'API Java.

Étape 1: créer un objet de cluster

Créer une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint("127.0.0.1");

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer l'objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“ Your keyspace name”);

Ici, nous utilisons le KeySpace nommé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“tp”);

Étape 3: Exécuter la requête

Dans l'exemple suivant, nous mettons à jour la table emp. Vous devez stocker la requête dans une variable de chaîne et la transmettre à la méthode execute () comme indiqué ci-dessous:

String query = “ UPDATE emp SET emp_city='Delhi',emp_sal=50000
WHERE emp_id = 2;” ;

Vous trouverez ci-dessous le programme complet pour mettre à jour les données dans une table à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Update_Data {
  
   public static void main(String args[]){
      
      //query
      String query = " UPDATE emp SET emp_city='Delhi',emp_sal=50000"
          
      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
         
      //Creating Session object
      Session session = cluster.connect("tp");
         
      //Executing the query
      session.execute(query);

      System.out.println("Data updated");
   }
 }

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Update_Data.java
$java Update_Data

Dans des conditions normales, il devrait produire la sortie suivante -

Data updated

Lecture des données à l'aide de la clause Select

La clause SELECT est utilisée pour lire les données d'une table dans Cassandra. En utilisant cette clause, vous pouvez lire une table entière, une seule colonne ou une cellule particulière. La syntaxe de la clause SELECT est donnée ci-dessous.

SELECT FROM <tablename>

Exemple

Supposons qu'il existe une table dans l'espace de clés nommé emp avec les détails suivants -

emp_id	nom_emp	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	merle	nul	9848022339	50000
3	rahman	Chennai	9848022330	50000
4	Rajeev	Pune	9848022331	30000

L'exemple suivant montre comment lire une table entière à l'aide de la clause SELECT. Ici, nous lisons un tableau appeléemp.

cqlsh:tutorialspoint> select * from emp;

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad |   ram    | 9848022338 | 50000
      2 | null      |   robin  | 9848022339 | 50000
      3 | Chennai   |   rahman | 9848022330 | 50000
      4 | Pune      |   rajeev | 9848022331 | 30000
		
(4 rows)

Lecture des colonnes requises

L'exemple suivant montre comment lire une colonne particulière dans une table.

cqlsh:tutorialspoint> SELECT emp_name, emp_sal from emp;

 emp_name | emp_sal
----------+---------
      ram | 50000
    robin | 50000
   rajeev | 30000
   rahman | 50000 
	
(4 rows)

Clause Où

En utilisant la clause WHERE, vous pouvez mettre une contrainte sur les colonnes requises. Sa syntaxe est la suivante -

SELECT FROM <table name> WHERE <condition>;

Note - Une clause WHERE ne peut être utilisée que sur les colonnes faisant partie de la clé primaire ou comportant un index secondaire.

Dans l'exemple suivant, nous lisons les détails d'un employé dont le salaire est de 50000. Tout d'abord, définissez l'index secondaire sur la colonne emp_sal.

cqlsh:tutorialspoint> CREATE INDEX ON emp(emp_sal);
cqlsh:tutorialspoint> SELECT * FROM emp WHERE emp_sal=50000;

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad |      ram | 9848022338 | 50000
      2 |      null |    robin | 9848022339 | 50000
      3 |   Chennai |   rahman | 9848022330 | 50000

Lire des données à l'aide de l'API Java

Vous pouvez lire les données d'une table en utilisant la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour exécuter plusieurs instructions à l'aide d'une instruction batch à l'aide de l'API Java.

Étape 1: créer un objet de cluster

Créer une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer l'objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“Your keyspace name”);

Ici, nous utilisons le KeySpace appelé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“tp”);

Étape 3: Exécuter la requête

Dans cet exemple, nous récupérons les données de emptable. Stockez la requête dans une chaîne et transmettez-la à la méthode execute () de la classe de session comme indiqué ci-dessous.

String query = ”SELECT 8 FROM emp”;
session.execute(query);

Exécutez la requête à l'aide de la méthode execute () de la classe Session.

Étape 4: Obtenez l'objet ResultSet

Les requêtes de sélection renverront le résultat sous la forme d'un ResultSet objet, stockez donc le résultat dans l'objet de RESULTSET classe comme indiqué ci-dessous.

ResultSet result = session.execute( );

Ci-dessous est le programme complet pour lire les données d'une table.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Session;

public class Read_Data {

   public static void main(String args[])throws Exception{
    
      //queries
      String query = "SELECT * FROM emp";

      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
    
      //Creating Session object
      Session session = cluster.connect("tutorialspoint");
    
      //Getting the ResultSet
      ResultSet result = session.execute(query);
    
      System.out.println(result.all());
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Read_Data.java
$java Read_Data

Dans des conditions normales, il devrait produire la sortie suivante -

[Row[1, Hyderabad, ram, 9848022338, 50000], Row[2, Delhi, robin,
9848022339, 50000], Row[4, Pune, rajeev, 9848022331, 30000], Row[3,
Chennai, rahman, 9848022330, 50000]]

Lecture des données à l'aide de la clause Select

SELECT FROM <tablename>

Exemple

Supposons qu'il existe une table dans l'espace de clés nommé emp avec les détails suivants -

emp_id	nom_emp	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	merle	nul	9848022339	50000
3	rahman	Chennai	9848022330	50000
4	Rajeev	Pune	9848022331	30000

L'exemple suivant montre comment lire une table entière à l'aide de la clause SELECT. Ici, nous lisons un tableau appeléemp.

cqlsh:tutorialspoint> select * from emp;

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad |   ram    | 9848022338 | 50000
      2 | null      |   robin  | 9848022339 | 50000
      3 | Chennai   |   rahman | 9848022330 | 50000
      4 | Pune      |   rajeev | 9848022331 | 30000
		
(4 rows)

Lecture des colonnes requises

L'exemple suivant montre comment lire une colonne particulière dans une table.

cqlsh:tutorialspoint> SELECT emp_name, emp_sal from emp;

 emp_name | emp_sal
----------+---------
      ram | 50000
    robin | 50000
   rajeev | 30000
   rahman | 50000 
	
(4 rows)

Clause Où

En utilisant la clause WHERE, vous pouvez mettre une contrainte sur les colonnes requises. Sa syntaxe est la suivante -

SELECT FROM <table name> WHERE <condition>;

Note - Une clause WHERE ne peut être utilisée que sur les colonnes faisant partie de la clé primaire ou comportant un index secondaire.

Dans l'exemple suivant, nous lisons les détails d'un employé dont le salaire est de 50000. Tout d'abord, définissez l'index secondaire sur la colonne emp_sal.

cqlsh:tutorialspoint> CREATE INDEX ON emp(emp_sal);
cqlsh:tutorialspoint> SELECT * FROM emp WHERE emp_sal=50000;

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad |      ram | 9848022338 | 50000
      2 |      null |    robin | 9848022339 | 50000
      3 |   Chennai |   rahman | 9848022330 | 50000

Lire des données à l'aide de l'API Java

Étape 1: créer un objet de cluster

Créer une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer l'objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect( );

Session session = cluster.connect(“Your keyspace name”);

Ici, nous utilisons le KeySpace appelé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“tp”);

Étape 3: Exécuter la requête

Dans cet exemple, nous récupérons les données de emptable. Stockez la requête dans une chaîne et transmettez-la à la méthode execute () de la classe de session comme indiqué ci-dessous.

String query = ”SELECT 8 FROM emp”;
session.execute(query);

Exécutez la requête à l'aide de la méthode execute () de la classe Session.

Étape 4: Obtenez l'objet ResultSet

Les requêtes de sélection renverront le résultat sous la forme d'un ResultSet objet, stockez donc le résultat dans l'objet de RESULTSET classe comme indiqué ci-dessous.

ResultSet result = session.execute( );

Ci-dessous est le programme complet pour lire les données d'une table.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Session;

public class Read_Data {

   public static void main(String args[])throws Exception{
    
      //queries
      String query = "SELECT * FROM emp";

      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
    
      //Creating Session object
      Session session = cluster.connect("tutorialspoint");
    
      //Getting the ResultSet
      ResultSet result = session.execute(query);
    
      System.out.println(result.all());
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Read_Data.java
$java Read_Data

Dans des conditions normales, il devrait produire la sortie suivante -

[Row[1, Hyderabad, ram, 9848022338, 50000], Row[2, Delhi, robin,
9848022339, 50000], Row[4, Pune, rajeev, 9848022331, 30000], Row[3,
Chennai, rahman, 9848022330, 50000]]

Suppression de données d'une table

Vous pouvez supprimer des données d'une table à l'aide de la commande DELETE. Sa syntaxe est la suivante -

DELETE FROM <identifier> WHERE <condition>;

Exemple

Supposons qu'il existe une table à Cassandra appelée emp ayant les données suivantes -

emp_id	nom_emp	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	merle	Hyderabad	9848022339	40000
3	rahman	Chennai	9848022330	45 000

L'instruction suivante supprime la colonne emp_sal de la dernière ligne -

cqlsh:tutorialspoint> DELETE emp_sal FROM emp WHERE emp_id=3;

Vérification

Utilisez l'instruction SELECT pour vérifier si les données ont été supprimées ou non. Si vous vérifiez la table emp en utilisant SELECT, elle produira la sortie suivante -

cqlsh:tutorialspoint> select * from emp;

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad |      ram | 9848022338 | 50000
      2 |     Delhi |    robin | 9848022339 | 50000
      3 |   Chennai |   rahman | 9848022330 | null
(3 rows)

Puisque nous avons supprimé le salaire de Rahman, vous observerez une valeur nulle à la place du salaire.

Supprimer une ligne entière

La commande suivante supprime une ligne entière d'une table.

cqlsh:tutorialspoint> DELETE FROM emp WHERE emp_id=3;

Vérification

Utilisez l'instruction SELECT pour vérifier si les données ont été supprimées ou non. Si vous vérifiez la table emp en utilisant SELECT, elle produira la sortie suivante -

cqlsh:tutorialspoint> select * from emp;

 emp_id |  emp_city | emp_name |  emp_phone | emp_sal
--------+-----------+----------+------------+---------
      1 | Hyderabad |      ram | 9848022338 | 50000
      2 |     Delhi |    robin | 9848022339 | 50000
 
(2 rows)

Depuis que nous avons supprimé la dernière ligne, il ne reste que deux lignes dans le tableau.

Suppression de données à l'aide de l'API Java

Vous pouvez supprimer des données dans une table à l'aide de la méthode execute () de la classe Session. Suivez les étapes ci-dessous pour supprimer des données d'une table à l'aide de l'API java.

Étape 1: créer un objet de cluster

Créer une instance de Cluster.builder une sorte de com.datastax.driver.core paquet comme indiqué ci-dessous.

//Creating Cluster.Builder object
Cluster.Builder builder1 = Cluster.builder();

Ajoutez un point de contact (adresse IP du nœud) à l'aide du addContactPoint() méthode de Cluster.Builderobjet. Cette méthode renvoieCluster.Builder.

//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );

//Building a cluster
Cluster cluster = builder.build();

Vous pouvez créer l'objet de cluster en utilisant une seule ligne de code comme indiqué ci-dessous.

Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();

Étape 2: créer un objet de session

Créez une instance de l'objet Session à l'aide de la méthode connect () de la classe Cluster comme indiqué ci-dessous.

Session session = cluster.connect();

Session session = cluster.connect(“ Your keyspace name ”);

Ici, nous utilisons le KeySpace appelé tp. Par conséquent, créez l'objet de session comme indiqué ci-dessous.

Session session = cluster.connect(“tp”);

Étape 3: Exécuter la requête

Dans l'exemple suivant, nous supprimons des données d'une table nommée emp. Vous devez stocker la requête dans une variable chaîne et la transmettre au execute() méthode comme indiqué ci-dessous.

String query1 = ”DELETE FROM emp WHERE emp_id=3; ”;
session.execute(query);

Vous trouverez ci-dessous le programme complet pour supprimer des données d'une table dans Cassandra à l'aide de l'API Java.

import com.datastax.driver.core.Cluster;
import com.datastax.driver.core.Session;

public class Delete_Data {

   public static void main(String args[]){
   
      //query
      String query = "DELETE FROM emp WHERE emp_id=3;";

      //Creating Cluster object
      Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
       
      //Creating Session object
      Session session = cluster.connect("tp");
       
      //Executing the query
      session.execute(query);
       
      System.out.println("Data deleted");
   }
}

Enregistrez le programme ci-dessus avec le nom de la classe suivi de .java, accédez à l'emplacement où il est enregistré. Compilez et exécutez le programme comme indiqué ci-dessous.

$javac Delete_Data.java
$java Delete_Data

Dans des conditions normales, il devrait produire la sortie suivante -

Data deleted

CQL fournit un ensemble complet de types de données intégrés, y compris des types de collection. Parallèlement à ces types de données, les utilisateurs peuvent également créer leurs propres types de données personnalisés. Le tableau suivant fournit une liste des types de données intégrés disponibles dans CQL.

Type de données	Constantes	La description
ascii	cordes	Représente la chaîne de caractères ASCII
bigint	bigint	Représente une longueur signée 64 bits
blob	blobs	Représente des octets arbitraires
Booléen	booléens	Représente vrai ou faux
counter	entiers	Représente la colonne de compteur
décimal	entiers, flottants	Représente un nombre décimal à précision variable
double	entiers	Représente la virgule flottante IEEE-754 64 bits
flotte	entiers, flottants	Représente la virgule flottante IEEE-754 32 bits
inet	cordes	Représente une adresse IP, IPv4 ou IPv6
int	entiers	Représente un entier signé 32 bits
texte	cordes	Représente la chaîne encodée en UTF8
timestamp	entiers, chaînes	Représente un horodatage
timeuuid	uuides	Représente l'UUID de type 1
uuid	uuides	Représente le type 1 ou le type 4
		UUID
varchar	cordes	Représente la chaîne encodée en uTF8
varint	entiers	Représente un entier de précision arbitraire

Types de collection

Cassandra Query Language fournit également une collection de types de données. Le tableau suivant fournit une liste des collections disponibles en CQL.

Collection	La description
liste	Une liste est une collection d'un ou plusieurs éléments ordonnés.
carte	Une carte est une collection de paires clé-valeur.
ensemble	Un ensemble est une collection d'un ou plusieurs éléments.

Types de données définis par l'utilisateur

Cqlsh offre aux utilisateurs la possibilité de créer leurs propres types de données. Vous trouverez ci-dessous les commandes utilisées lors du traitement des types de données définis par l'utilisateur.

CREATE TYPE - Crée un type de données défini par l'utilisateur.
ALTER TYPE - Modifie un type de données défini par l'utilisateur.
DROP TYPE - Supprime un type de données défini par l'utilisateur.
DESCRIBE TYPE - Décrit un type de données défini par l'utilisateur.
DESCRIBE TYPES - Décrit les types de données définis par l'utilisateur.

CQL offre la possibilité d'utiliser les types de données Collection. En utilisant ces types de collection, vous pouvez stocker plusieurs valeurs dans une seule variable. Ce chapitre explique comment utiliser les collections dans Cassandra.

liste

La liste est utilisée dans les cas où

l'ordre des éléments doit être maintenu, et
une valeur doit être stockée plusieurs fois.

Vous pouvez obtenir les valeurs d'un type de données de liste à l'aide de l'index des éléments de la liste.

Créer une table avec une liste

Vous trouverez ci-dessous un exemple pour créer un exemple de table avec deux colonnes, nom et e-mail. Pour stocker plusieurs e-mails, nous utilisons la liste.

cqlsh:tutorialspoint> CREATE TABLE data(name text PRIMARY KEY, email list<text>);

Insertion de données dans une liste

Lors de l'insertion de données dans les éléments d'une liste, entrez toutes les valeurs séparées par une virgule entre crochets [] comme indiqué ci-dessous.

cqlsh:tutorialspoint> INSERT INTO data(name, email) VALUES ('ramu',
['[email protected]','[email protected]'])

Mettre à jour une liste

Vous trouverez ci-dessous un exemple pour mettre à jour le type de données de liste dans une table appelée data. Ici, nous ajoutons un autre e-mail à la liste.

cqlsh:tutorialspoint> UPDATE data
... SET email = email +['[email protected]']
... where name = 'ramu';

Vérification

Si vous vérifiez la table à l'aide de l'instruction SELECT, vous obtiendrez le résultat suivant -

cqlsh:tutorialspoint> SELECT * FROM data;

 name | email
------+--------------------------------------------------------------
 ramu | ['[email protected]', '[email protected]', '[email protected]']

(1 rows)

ENSEMBLE

Set est un type de données utilisé pour stocker un groupe d'éléments. Les éléments d'un ensemble seront renvoyés dans un ordre trié.

Créer une table avec Set

L'exemple suivant crée un exemple de table avec deux colonnes, nom et téléphone. Pour stocker plusieurs numéros de téléphone, nous utilisons set.

cqlsh:tutorialspoint> CREATE TABLE data2 (name text PRIMARY KEY, phone set<varint>);

Insertion de données dans un ensemble

Lors de l'insertion de données dans les éléments d'un ensemble, entrez toutes les valeurs séparées par une virgule entre accolades {} comme indiqué ci-dessous.

cqlsh:tutorialspoint> INSERT INTO data2(name, phone)VALUES ('rahman',    {9848022338,9848022339});

Mettre à jour un ensemble

Le code suivant montre comment mettre à jour un ensemble dans une table nommée data2. Ici, nous ajoutons un autre numéro de téléphone à l'ensemble.

cqlsh:tutorialspoint> UPDATE data2
   ... SET phone = phone + {9848022330}
   ... where name = 'rahman';

Vérification

Si vous vérifiez la table à l'aide de l'instruction SELECT, vous obtiendrez le résultat suivant -

cqlsh:tutorialspoint> SELECT * FROM data2;

   name | phone
--------+--------------------------------------
 rahman | {9848022330, 9848022338, 9848022339}

(1 rows)

CARTE

Map est un type de données utilisé pour stocker une paire d'éléments clé-valeur.

Créer une table avec une carte

L'exemple suivant montre comment créer un exemple de table avec deux colonnes, nom et adresse. Pour stocker plusieurs valeurs d'adresse, nous utilisons map.

cqlsh:tutorialspoint> CREATE TABLE data3 (name text PRIMARY KEY, address
map<timestamp, text>);

Insertion de données dans une carte

Lors de l'insertion de données dans les éléments d'une carte, saisissez tous les key : value paires séparées par une virgule entre accolades {} comme indiqué ci-dessous.

cqlsh:tutorialspoint> INSERT INTO data3 (name, address)
   VALUES ('robin', {'home' : 'hyderabad' , 'office' : 'Delhi' } );

Mettre à jour un ensemble

Le code suivant montre comment mettre à jour le type de données de carte dans une table nommée data3. Ici, nous modifions la valeur du bureau principal, c'est-à-dire que nous changeons l'adresse du bureau d'une personne nommée robin.

cqlsh:tutorialspoint> UPDATE data3
   ... SET address = address+{'office':'mumbai'}
   ... WHERE name = 'robin';

Vérification

Si vous vérifiez la table à l'aide de l'instruction SELECT, vous obtiendrez le résultat suivant -

cqlsh:tutorialspoint> select * from data3;

  name | address
-------+-------------------------------------------
 robin | {'home': 'hyderabad', 'office': 'mumbai'}

(1 rows)

CQL offre la possibilité de créer et d'utiliser des types de données définis par l'utilisateur. Vous pouvez créer un type de données pour gérer plusieurs champs. Ce chapitre explique comment créer, modifier et supprimer un type de données défini par l'utilisateur.

Création d'un type de données défini par l'utilisateur

La commande CREATE TYPEest utilisé pour créer un type de données défini par l'utilisateur. Sa syntaxe est la suivante -

CREATE TYPE <keyspace name>. <data typename>
( variable1, variable2).

Exemple

Vous trouverez ci-dessous un exemple de création d'un type de données défini par l'utilisateur. Dans cet exemple, nous créons uncard_details type de données contenant les détails suivants.

Champ	Nom de domaine	Type de données
carte de crédit non	num	int
broche de carte de crédit	épingle	int
Nom sur la carte de crédit	Nom	texte
cvv	cvv	int
Coordonnées du titulaire de la carte	téléphone	ensemble

cqlsh:tutorialspoint> CREATE TYPE card_details (
   ... num int,
   ... pin int,
   ... name text,
   ... cvv int,
   ... phone set<int>
... );

Note - Le nom utilisé pour le type de données défini par l'utilisateur ne doit pas coïncider avec les noms de type réservés.

Vérification

Utilisez le DESCRIBE pour vérifier si le type créé a été créé ou non.

CREATE TYPE tutorialspoint.card_details (
   num int,
   pin int,
   name text,
   cvv int,
   phone set<int>
   );

Modification d'un type de données défini par l'utilisateur

ALTER TYPE- la commande est utilisée pour modifier un type de données existant. En utilisant ALTER, vous pouvez ajouter un nouveau champ ou renommer un champ existant.

Ajout d'un champ à un type

Utilisez la syntaxe suivante pour ajouter un nouveau champ à un type de données défini par l'utilisateur existant.

ALTER TYPE typename
ADD field_name field_type;

Le code suivant ajoute un nouveau champ au Card_detailsType de données. Ici, nous ajoutons un nouveau champ appelé email.

cqlsh:tutorialspoint> ALTER TYPE card_details ADD email text;

Vérification

Utilisez le DESCRIBE pour vérifier si le nouveau champ est ajouté ou non.

cqlsh:tutorialspoint> describe type card_details;
CREATE TYPE tutorialspoint.card_details (
   num int,
   pin int,
   name text,
   cvv int,
   phone set<int>,
   );

Renommer un champ dans un type

Utilisez la syntaxe suivante pour renommer un type de données défini par l'utilisateur existant.

ALTER TYPE typename
RENAME existing_name TO new_name;

Le code suivant modifie le nom du champ dans un type. Ici, nous renommons le champ email en mail.

cqlsh:tutorialspoint> ALTER TYPE card_details RENAME email TO mail;

Vérification

Utilisez le DESCRIBE pour vérifier si le nom du type a changé ou non.

cqlsh:tutorialspoint> describe type card_details;
CREATE TYPE tutorialspoint.card_details (
   num int,
   pin int,
   name text,
   cvv int,
   phone set<int>,
   mail text
   );

Suppression d'un type de données défini par l'utilisateur

DROP TYPEest la commande utilisée pour supprimer un type de données défini par l'utilisateur. Vous trouverez ci-dessous un exemple de suppression d'un type de données défini par l'utilisateur.

Exemple

Avant de supprimer, vérifiez la liste de tous les types de données définis par l'utilisateur à l'aide de DESCRIBE_TYPES comme indiqué ci-dessous.

cqlsh:tutorialspoint> DESCRIBE TYPES;
card_details card

Parmi les deux types, supprimez le type nommé card comme indiqué ci-dessous.

cqlsh:tutorialspoint> drop type card;

Utilisez le DESCRIBE pour vérifier si le type de données a été supprimé ou non.

cqlsh:tutorialspoint> describe types;

card_details