Cassandra - Kurzanleitung

Apache Cassandra ist eine hoch skalierbare, hochleistungsfähige verteilte Datenbank, die für die Verarbeitung großer Datenmengen auf vielen Commodity-Servern ausgelegt ist und eine hohe Verfügbarkeit ohne Single Point of Failure bietet. Es ist eine Art NoSQL-Datenbank. Lassen Sie uns zunächst verstehen, was eine NoSQL-Datenbank tut.

NoSQLDatabase

Eine NoSQL-Datenbank (manchmal auch als Not Only SQL bezeichnet) ist eine Datenbank, die einen Mechanismus zum Speichern und Abrufen anderer Daten als der in relationalen Datenbanken verwendeten tabellarischen Beziehungen bietet. Diese Datenbanken sind schemafrei, unterstützen eine einfache Replikation, verfügen über eine einfache API, sind schließlich konsistent und können große Datenmengen verarbeiten.

Das Hauptziel einer NoSQL-Datenbank ist es, zu haben

Einfachheit des Designs,
horizontale Skalierung und
feinere Kontrolle über die Verfügbarkeit.

NoSql-Datenbanken verwenden andere Datenstrukturen als relationale Datenbanken. Es beschleunigt einige Operationen in NoSQL. Die Eignung einer bestimmten NoSQL-Datenbank hängt von dem Problem ab, das sie lösen muss.

NoSQL vs. relationale Datenbank

In der folgenden Tabelle sind die Punkte aufgeführt, die eine relationale Datenbank von einer NoSQL-Datenbank unterscheiden.

Relationale Datenbank	NoSql-Datenbank
Unterstützt leistungsstarke Abfragesprache.	Unterstützt eine sehr einfache Abfragesprache.
Es hat ein festes Schema.	Kein festes Schema.
Folgt ACID (Atomizität, Konsistenz, Isolierung und Haltbarkeit).	Es ist nur "irgendwann konsistent".
Unterstützt Transaktionen.	Unterstützt keine Transaktionen.

Neben Cassandra haben wir die folgenden NoSQL-Datenbanken, die sehr beliebt sind -

Apache HBase- HBase ist eine nicht relationale, verteilte Open-Source-Datenbank, die dem BigTable von Google nachempfunden und in Java geschrieben ist. Es wurde als Teil des Apache Hadoop-Projekts entwickelt und läuft auf HDFS auf und bietet BigTable-ähnliche Funktionen für Hadoop.
MongoDB - MongoDB ist ein plattformübergreifendes dokumentenorientiertes Datenbanksystem, bei dem die Verwendung der traditionellen tabellenbasierten relationalen Datenbankstruktur zugunsten von JSON-ähnlichen Dokumenten mit dynamischen Schemata vermieden wird, wodurch die Integration von Daten in bestimmte Arten von Anwendungen einfacher und schneller wird.

Was ist Apache Cassandra?

Apache Cassandra ist ein Open Source, verteiltes und dezentrales / verteiltes Speichersystem (Datenbank) zur Verwaltung sehr großer Mengen strukturierter Daten, die auf der ganzen Welt verteilt sind. Es bietet hochverfügbaren Service ohne Single Point of Failure.

Nachfolgend sind einige der bemerkenswerten Punkte von Apache Cassandra aufgeführt -

Es ist skalierbar, fehlertolerant und konsistent.
Es ist eine spaltenorientierte Datenbank.
Das Distributionsdesign basiert auf Amazon Dynamo und das Datenmodell auf Googles Bigtable.
Es wurde bei Facebook erstellt und unterscheidet sich stark von relationalen Datenbankverwaltungssystemen.
Cassandra implementiert ein Replikationsmodell im Dynamo-Stil ohne Single Point of Failure, fügt jedoch ein leistungsfähigeres Datenmodell für die Spaltenfamilie hinzu.
Cassandra wird von einigen der größten Unternehmen wie Facebook, Twitter, Cisco, Rackspace, eBay, Twitter, Netflix und anderen verwendet.

Eigenschaften von Cassandra

Cassandra ist wegen seiner herausragenden technischen Eigenschaften so beliebt geworden. Im Folgenden sind einige der Funktionen von Cassandra aufgeführt:

Elastic scalability- Cassandra ist hoch skalierbar; Es ermöglicht das Hinzufügen von mehr Hardware, um je nach Anforderung mehr Kunden und mehr Daten aufzunehmen.
Always on architecture - Cassandra hat keinen einzigen Fehlerpunkt und ist kontinuierlich für geschäftskritische Anwendungen verfügbar, die sich einen Fehler nicht leisten können.
Fast linear-scale performance- Cassandra ist linear skalierbar, dh es erhöht Ihren Durchsatz, wenn Sie die Anzahl der Knoten im Cluster erhöhen. Daher bleibt eine schnelle Reaktionszeit erhalten.
Flexible data storage- Cassandra unterstützt alle möglichen Datenformate, einschließlich: strukturiert, halbstrukturiert und unstrukturiert. Es kann Änderungen an Ihren Datenstrukturen je nach Bedarf dynamisch berücksichtigen.
Easy data distribution - Cassandra bietet die Flexibilität, Daten nach Bedarf zu verteilen, indem Daten auf mehrere Rechenzentren repliziert werden.
Transaction support - Cassandra unterstützt Eigenschaften wie Atomizität, Konsistenz, Isolation und Haltbarkeit (ACID).
Fast writes- Cassandra wurde für den Betrieb mit billiger Standardhardware entwickelt. Es führt blitzschnelle Schreibvorgänge durch und kann Hunderte von Terabyte an Daten speichern, ohne die Leseeffizienz zu beeinträchtigen.

Geschichte von Cassandra

Cassandra wurde bei Facebook für die Posteingangssuche entwickelt.
Es wurde im Juli 2008 von Facebook als Open-Source-Version bereitgestellt.
Cassandra wurde im März 2009 in Apache Incubator aufgenommen.
Es wurde seit Februar 2010 zu einem Apache-Top-Level-Projekt gemacht.

Das Entwurfsziel von Cassandra besteht darin, Big-Data-Workloads über mehrere Knoten hinweg ohne einen einzigen Fehlerpunkt zu verarbeiten. Cassandra verfügt über ein Peer-to-Peer-System, das auf seine Knoten verteilt ist, und Daten werden auf alle Knoten in einem Cluster verteilt.

Alle Knoten in einem Cluster spielen dieselbe Rolle. Jeder Knoten ist unabhängig und gleichzeitig mit anderen Knoten verbunden.
Jeder Knoten in einem Cluster kann Lese- und Schreibanforderungen akzeptieren, unabhängig davon, wo sich die Daten tatsächlich im Cluster befinden.
Wenn ein Knoten ausfällt, können Lese- / Schreibanforderungen von anderen Knoten im Netzwerk bedient werden.

Datenreplikation in Cassandra

In Cassandra fungieren einer oder mehrere der Knoten in einem Cluster als Replikate für ein bestimmtes Datenelement. Wenn festgestellt wird, dass einige der Knoten mit einem veralteten Wert geantwortet haben, gibt Cassandra den neuesten Wert an den Client zurück. Nach der Rückgabe des letzten Werts führt Cassandra a ausread repair im Hintergrund, um die veralteten Werte zu aktualisieren.

Die folgende Abbildung zeigt eine schematische Ansicht, wie Cassandra die Datenreplikation zwischen den Knoten in einem Cluster verwendet, um sicherzustellen, dass kein einzelner Fehlerpunkt auftritt.

Note - Cassandra benutzt die Gossip Protocol im Hintergrund, damit die Knoten miteinander kommunizieren und fehlerhafte Knoten im Cluster erkennen können.

Komponenten von Cassandra

Die Schlüsselkomponenten von Cassandra sind wie folgt:

Node - Hier werden Daten gespeichert.
Data center - Es ist eine Sammlung verwandter Knoten.
Cluster - Ein Cluster ist eine Komponente, die ein oder mehrere Rechenzentren enthält.
Commit log- Das Festschreibungsprotokoll ist ein Mechanismus zur Wiederherstellung nach einem Absturz in Cassandra. Jede Schreiboperation wird in das Festschreibungsprotokoll geschrieben.
Mem-table- Eine Mem-Tabelle ist eine speicherresidente Datenstruktur. Nach dem Festschreibungsprotokoll werden die Daten in die Mem-Tabelle geschrieben. Manchmal gibt es für eine einspaltige Familie mehrere Mem-Tabellen.
SSTable - Es handelt sich um eine Datenträgerdatei, in die die Daten aus der Mem-Tabelle gelöscht werden, wenn ihr Inhalt einen Schwellenwert erreicht.
Bloom filter- Dies sind nichts anderes als schnelle, nicht deterministische Algorithmen zum Testen, ob ein Element Mitglied einer Menge ist. Es ist eine besondere Art von Cache. Auf Bloom-Filter wird nach jeder Abfrage zugegriffen.

Cassandra-Abfragesprache

Benutzer können über ihre Knoten mit Cassandra Query Language (CQL) auf Cassandra zugreifen. CQL behandelt die Datenbank(Keyspace)als Container von Tabellen. Programmierer verwendencqlsh: eine Aufforderung, mit CQL oder separaten Anwendungssprachentreibern zu arbeiten.

Clients nähern sich einem der Knoten für ihre Lese- / Schreibvorgänge. Dieser Knoten (Koordinator) spielt einen Proxy zwischen dem Client und den Knoten, die die Daten enthalten.

Schreibvorgänge

Jede Schreibaktivität von Knoten wird von der erfasst commit logsin den Knoten geschrieben. Später werden die Daten erfasst und im gespeichertmem-table. Immer wenn die Mem-Tabelle voll ist, werden Daten in die geschrieben SStableDatendatei. Alle Schreibvorgänge werden automatisch partitioniert und im gesamten Cluster repliziert. Cassandra konsolidiert die SSTables regelmäßig und verwirft unnötige Daten.

Operationen lesen

Während des Lesevorgangs erhält Cassandra Werte aus der Mem-Tabelle und überprüft den Bloom-Filter, um die entsprechende SSTable zu finden, die die erforderlichen Daten enthält.

Das Datenmodell von Cassandra unterscheidet sich erheblich von dem, was wir normalerweise in einem RDBMS sehen. Dieses Kapitel bietet einen Überblick darüber, wie Cassandra seine Daten speichert.

Cluster

Die Cassandra-Datenbank ist auf mehrere Computer verteilt, die zusammenarbeiten. Der äußerste Container wird als Cluster bezeichnet. Für die Fehlerbehandlung enthält jeder Knoten ein Replikat, und im Falle eines Fehlers übernimmt das Replikat die Verantwortung. Cassandra ordnet die Knoten in einem Cluster in einem Ringformat an und weist ihnen Daten zu.

Schlüsselraum

Keyspace ist der äußerste Container für Daten in Cassandra. Die grundlegenden Attribute eines Keyspace in Cassandra sind -

Replication factor - Dies ist die Anzahl der Computer im Cluster, die Kopien derselben Daten empfangen.
Replica placement strategy- Es ist nichts anderes als die Strategie, Repliken in den Ring zu legen. Wir haben Strategien wiesimple strategy (Rack-Aware-Strategie), old network topology strategy (Rack-Aware-Strategie) und network topology strategy (Strategie für gemeinsam genutzte Rechenzentren).
Column families- Keyspace ist ein Container für eine Liste einer oder mehrerer Spaltenfamilien. Eine Spaltenfamilie ist wiederum ein Container einer Sammlung von Zeilen. Jede Zeile enthält geordnete Spalten. Spaltenfamilien repräsentieren die Struktur Ihrer Daten. Jeder Schlüsselbereich hat mindestens eine und häufig viele Spaltenfamilien.

Die Syntax zum Erstellen eines Schlüsselraums lautet wie folgt:

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

Die folgende Abbildung zeigt eine schematische Ansicht eines Schlüsselraums.

Spaltenfamilie

Eine Spaltenfamilie ist ein Container für eine geordnete Sammlung von Zeilen. Jede Zeile ist wiederum eine geordnete Sammlung von Spalten. In der folgenden Tabelle sind die Punkte aufgeführt, die eine Spaltenfamilie von einer Tabelle relationaler Datenbanken unterscheiden.

Relationale Tabelle	Cassandra-Säulenfamilie
Ein Schema in einem relationalen Modell ist festgelegt. Sobald wir beim Einfügen von Daten bestimmte Spalten für eine Tabelle definiert haben, müssen in jeder Zeile alle Spalten mindestens mit einem Nullwert gefüllt sein.	In Cassandra sind die Spaltenfamilien zwar definiert, die Spalten jedoch nicht. Sie können jeder Spaltenfamilie jederzeit eine beliebige Spalte hinzufügen.
Relationale Tabellen definieren nur Spalten und der Benutzer füllt die Tabelle mit Werten aus.	In Cassandra enthält eine Tabelle Spalten oder kann als Superspaltenfamilie definiert werden.

Eine Cassandra-Spaltenfamilie weist die folgenden Attribute auf:

keys_cached - Es gibt die Anzahl der Speicherorte an, die pro SSTable zwischengespeichert werden sollen.
rows_cached - Es gibt die Anzahl der Zeilen an, deren gesamter Inhalt im Speicher zwischengespeichert wird.
preload_row_cache - Gibt an, ob Sie den Zeilencache vorab füllen möchten.

Note − Im Gegensatz zu relationalen Tabellen, in denen das Schema einer Spaltenfamilie nicht festgelegt ist, erzwingt Cassandra nicht, dass einzelne Zeilen alle Spalten enthalten.

Die folgende Abbildung zeigt ein Beispiel einer Cassandra-Spaltenfamilie.

Säule

Eine Spalte ist die grundlegende Datenstruktur von Cassandra mit drei Werten, nämlich Schlüssel- oder Spaltenname, Wert und Zeitstempel. Unten ist die Struktur einer Spalte angegeben.

SuperColumn

Eine Superspalte ist eine spezielle Spalte, daher ist sie auch ein Schlüssel-Wert-Paar. In einer Superspalte wird jedoch eine Karte mit Unterspalten gespeichert.

Im Allgemeinen werden Spaltenfamilien in einzelnen Dateien auf der Festplatte gespeichert. Um die Leistung zu optimieren, ist es daher wichtig, Spalten, die Sie wahrscheinlich zusammen abfragen, in derselben Spaltenfamilie zu belassen. Eine Superspalte kann hier hilfreich sein. Im Folgenden wird die Struktur einer Superspalte angegeben.

Datenmodelle von Cassandra und RDBMS

In der folgenden Tabelle sind die Punkte aufgeführt, die das Datenmodell von Cassandra von dem eines RDBMS unterscheiden.

RDBMS	Kassandra
RDBMS befasst sich mit strukturierten Daten.	Cassandra befasst sich mit unstrukturierten Daten.
Es hat ein festes Schema.	Cassandra hat ein flexibles Schema.
In RDBMS ist eine Tabelle ein Array von Arrays. (REIHE x SPALTE)	In Cassandra ist eine Tabelle eine Liste von "verschachtelten Schlüssel-Wert-Paaren". (ROW x COLUMN-Taste x COLUMN-Wert)
Datenbank ist der äußerste Container, der Daten enthält, die einer Anwendung entsprechen.	Der Schlüsselbereich ist der äußerste Container, der Daten enthält, die einer Anwendung entsprechen.
Tabellen sind die Entitäten einer Datenbank.	Tabellen oder Spaltenfamilien sind die Entität eines Schlüsselbereichs.
Zeile ist ein einzelner Datensatz in RDBMS.	Row ist eine Replikationseinheit in Cassandra.
Die Spalte repräsentiert die Attribute einer Beziehung.	Die Säule ist eine Speichereinheit in Cassandra.
RDBMS unterstützt die Konzepte von Fremdschlüsseln und Joins.	Beziehungen werden mithilfe von Sammlungen dargestellt.

Auf Cassandra kann sowohl mit cqlsh als auch mit Treibern verschiedener Sprachen zugegriffen werden. In diesem Kapitel wird erläutert, wie Sie sowohl cqlsh- als auch Java-Umgebungen für die Arbeit mit Cassandra einrichten.

Setup vor der Installation

Vor der Installation von Cassandra in einer Linux-Umgebung müssen wir Linux mit einrichten ssh(Sichere Shell). Führen Sie die folgenden Schritte aus, um die Linux-Umgebung einzurichten.

Erstellen Sie einen Benutzer

Zu Beginn wird empfohlen, einen separaten Benutzer für Hadoop zu erstellen, um das Hadoop-Dateisystem vom Unix-Dateisystem zu isolieren. Führen Sie die folgenden Schritte aus, um einen Benutzer zu erstellen.

Öffnen Sie root mit dem Befehl “su”.
Erstellen Sie mit dem Befehl einen Benutzer aus dem Root-Konto “useradd username”.
Jetzt können Sie mit dem Befehl ein vorhandenes Benutzerkonto eröffnen “su username”.

Öffnen Sie das Linux-Terminal und geben Sie die folgenden Befehle ein, um einen Benutzer zu erstellen.

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

SSH-Setup und Schlüsselgenerierung

Das SSH-Setup ist erforderlich, um verschiedene Vorgänge in einem Cluster auszuführen, z. B. das Starten, Stoppen und Verteilen von Daemon-Shell-Vorgängen. Um verschiedene Benutzer von Hadoop zu authentifizieren, muss ein öffentliches / privates Schlüsselpaar für einen Hadoop-Benutzer bereitgestellt und für verschiedene Benutzer freigegeben werden.

Die folgenden Befehle werden zum Generieren eines Schlüsselwertpaars mit SSH verwendet:

Kopieren Sie die öffentlichen Schlüssel von id_rsa.pub nach autorisierten Schlüsseln.
und bieten Eigentümer,
Lese- und Schreibberechtigungen für die Datei "authorized_keys".

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

Überprüfen Sie ssh:

ssh localhost

Java installieren

Java ist die Hauptvoraussetzung für Cassandra. Zunächst sollten Sie die Existenz von Java in Ihrem System mit dem folgenden Befehl überprüfen:

$ java -version

Wenn alles gut funktioniert, erhalten Sie die folgende Ausgabe.

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)

Wenn Sie kein Java in Ihrem System haben, führen Sie die folgenden Schritte aus, um Java zu installieren.

Schritt 1

Laden Sie Java (JDK <neueste Version> - X64.tar.gz) über den folgenden Link herunter :

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

Schritt 2

Im Allgemeinen finden Sie die heruntergeladene Java-Datei im Ordner Downloads. Überprüfen Sie es und extrahieren Sie diejdk-7u71-linux-x64.gz Datei mit den folgenden Befehlen.

$ 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

Schritt 3

Um Java für alle Benutzer verfügbar zu machen, müssen Sie es an den Speicherort "/ usr / local /" verschieben. Öffnen Sie root und geben Sie die folgenden Befehle ein.

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

Schritt 4

Zum Einrichten PATH und JAVA_HOME Variablen, fügen Sie die folgenden Befehle hinzu ~/.bashrc Datei.

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

Übernehmen Sie nun alle Änderungen in das aktuell laufende System.

$ source ~/.bashrc

Schritt 5

Verwenden Sie die folgenden Befehle, um Java-Alternativen zu konfigurieren.

# 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

Verwenden Sie jetzt die java -version Befehl vom Terminal wie oben erläutert.

Pfad festlegen

Stellen Sie den Pfad des Cassandra-Pfads in „/.bashrc“ wie unten gezeigt ein.

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

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

Laden Sie Cassandra herunter

Apache Cassandra ist unter Download Link Cassandra mit dem folgenden Befehl verfügbar .

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

Entpacken Sie Cassandra mit dem Befehl zxvf Wie nachfolgend dargestellt.

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

Erstellen Sie ein neues Verzeichnis mit dem Namen cassandra und verschieben Sie den Inhalt der heruntergeladenen Datei wie unten gezeigt in dieses Verzeichnis.

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

Konfigurieren Sie Cassandra

Öffne das cassandra.yaml: Datei, die in der verfügbar sein wird bin Verzeichnis von Cassandra.

$ gedit cassandra.yaml

Note - Wenn Sie Cassandra von einem Deb- oder RPM-Paket installiert haben, befinden sich die Konfigurationsdateien in /etc/cassandra Verzeichnis von Cassandra.

Der obige Befehl öffnet die cassandra.yamlDatei. Überprüfen Sie die folgenden Konfigurationen. Standardmäßig werden diese Werte auf die angegebenen Verzeichnisse festgelegt.

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

Stellen Sie sicher, dass diese Verzeichnisse vorhanden sind und wie unten gezeigt beschrieben werden können.

Verzeichnisse erstellen

Erstellen Sie als Superuser die beiden Verzeichnisse /var/lib/cassandra und /var./log/cassandra in die Cassandra ihre Daten schreibt.

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

Geben Sie Ordnern Berechtigungen

Geben Sie den neu erstellten Ordnern Lese- / Schreibberechtigungen, wie unten gezeigt.

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

Starten Sie Cassandra

Um Cassandra zu starten, öffnen Sie das Terminalfenster, navigieren Sie zum Cassandra-Ausgangsverzeichnis / home, in dem Sie Cassandra entpackt haben, und führen Sie den folgenden Befehl aus, um Ihren Cassandra-Server zu starten.

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

Wenn Sie die Option –f verwenden, wird Cassandra angewiesen, im Vordergrund zu bleiben, anstatt als Hintergrundprozess ausgeführt zu werden. Wenn alles gut geht, wird der Cassandra-Server gestartet.

Programmierumgebung

Laden Sie die folgenden JAR-Dateien herunter, um Cassandra programmgesteuert einzurichten:

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

Legen Sie sie in einen separaten Ordner. Zum Beispiel laden wir diese Gläser in einen Ordner mit dem Namen herunter“Cassandra_jars”.

Legen Sie den Klassenpfad für diesen Ordner in fest “.bashrc”Datei wie unten gezeigt.

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

Eclipse-Umgebung

Öffnen Sie Eclipse und erstellen Sie ein neues Projekt namens Cassandra _Examples.

Klicken Sie mit der rechten Maustaste auf das Projekt und wählen Sie Build Path→Configure Build Path Wie nachfolgend dargestellt.

Das Eigenschaftenfenster wird geöffnet. Wählen Sie auf der Registerkarte Bibliotheken die Option ausAdd External JARs. Navigieren Sie zu dem Verzeichnis, in dem Sie Ihre JAR-Dateien gespeichert haben. Wählen Sie alle fünf JAR-Dateien aus und klicken Sie wie unten gezeigt auf OK.

Unter Referenzierte Bibliotheken sehen Sie alle erforderlichen Gläser, die wie unten gezeigt hinzugefügt wurden.

Maven-Abhängigkeiten

Im Folgenden finden Sie die Datei pom.xml zum Erstellen eines Cassandra-Projekts mit 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>

Dieses Kapitel behandelt alle wichtigen Klassen in Cassandra.

Cluster

Diese Klasse ist der Haupteinstiegspunkt des Fahrers. Es gehörtcom.datastax.driver.core Paket.

Methoden

S. Nr.	Methoden und Beschreibung
1	Session connect() Es erstellt eine neue Sitzung im aktuellen Cluster und initialisiert sie.
2	void close() Es wird verwendet, um die Clusterinstanz zu schließen.
3	static Cluster.Builder builder() Es wird verwendet, um eine neue Cluster.Builder-Instanz zu erstellen.

Cluster.Builder

Diese Klasse wird verwendet, um das zu instanziieren Cluster.Builder Klasse.

Methoden

S. Nr	Methoden und Beschreibung
1	Cluster.Builder addContactPoint(String address) Diese Methode fügt dem Cluster einen Kontaktpunkt hinzu.
2	Cluster build() Diese Methode erstellt den Cluster mit den angegebenen Kontaktpunkten.

Session

Diese Schnittstelle enthält die Verbindungen zum Cassandra-Cluster. Über diese Schnittstelle können Sie ausführenCQLAnfragen. Es gehörtcom.datastax.driver.core Paket.

Methoden

S. Nr.	Methoden und Beschreibung
1	void close() Diese Methode wird verwendet, um die aktuelle Sitzungsinstanz zu schließen.
2	ResultSet execute(Statement statement) Diese Methode wird verwendet, um eine Abfrage auszuführen. Es erfordert ein Anweisungsobjekt.
3	ResultSet execute(String query) Diese Methode wird verwendet, um eine Abfrage auszuführen. Es erfordert eine Abfrage in Form eines String-Objekts.
4	PreparedStatement prepare(RegularStatement statement) Diese Methode bereitet die bereitgestellte Abfrage vor. Die Abfrage ist in Form einer Erklärung bereitzustellen.
5	PreparedStatement prepare(String query) Diese Methode bereitet die bereitgestellte Abfrage vor. Die Abfrage ist in Form eines Strings bereitzustellen.

In diesem Kapitel wird die Cassandra-Shell für Abfragesprachen vorgestellt und die Verwendung ihrer Befehle erläutert.

Standardmäßig bietet Cassandra eine sofortige Cassandra-Abfragesprachen-Shell (cqlsh)Dadurch können Benutzer mit ihm kommunizieren. Mit dieser Shell können Sie ausführenCassandra Query Language (CQL).

Mit cqlsh können Sie

ein Schema definieren,
Daten einfügen und
eine Abfrage ausführen.

Cqlsh starten

Starten Sie cqlsh mit dem Befehl cqlshWie nachfolgend dargestellt. Es gibt die Cassandra cqlsh-Eingabeaufforderung als Ausgabe.

[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- Wie oben erläutert, wird dieser Befehl verwendet, um die Eingabeaufforderung cqlsh zu starten. Darüber hinaus werden einige weitere Optionen unterstützt. In der folgenden Tabelle werden alle Optionen von erläutertcqlsh und ihre Verwendung.

Optionen	Verwendung
cqlsh --help	Zeigt Hilfethemen zu den Optionen von an cqlsh Befehle.
cqlsh --version	Stellt die Version des von Ihnen verwendeten cqlsh bereit.
cqlsh - Farbe	Weist die Shell an, eine farbige Ausgabe zu verwenden.
cqlsh --debug	Zeigt zusätzliche Debugging-Informationen an.
cqlsh - ausführen cql_statement	Weist die Shell an, einen CQL-Befehl zu akzeptieren und auszuführen.
cqlsh --file = “file name”	Wenn Sie diese Option verwenden, führt Cassandra den Befehl in der angegebenen Datei aus und wird beendet.
cqlsh - keine Farbe	Weist Cassandra an, keine farbige Ausgabe zu verwenden.
cqlsh -u “user name”	Mit dieser Option können Sie einen Benutzer authentifizieren. Der Standardbenutzername lautet: Cassandra.
cqlsh-p “pass word”	Mit dieser Option können Sie einen Benutzer mit einem Kennwort authentifizieren. Das Standardkennwort lautet: Cassandra.

Cqlsh-Befehle

Cqlsh verfügt über einige Befehle, mit denen Benutzer damit interagieren können. Die Befehle sind unten aufgeführt.

Dokumentierte Shell-Befehle

Im Folgenden sind die von Cqlsh dokumentierten Shell-Befehle aufgeführt. Dies sind die Befehle, die zum Ausführen von Aufgaben wie Anzeigen von Hilfethemen, Beenden von cqlsh, Beschreiben usw. Verwendet werden.

HELP - Zeigt Hilfethemen für alle cqlsh-Befehle an.
CAPTURE - Erfasst die Ausgabe eines Befehls und fügt ihn einer Datei hinzu.
CONSISTENCY - Zeigt die aktuelle Konsistenzstufe an oder legt eine neue Konsistenzstufe fest.
COPY - Kopiert Daten von und nach Cassandra.
DESCRIBE - Beschreibt den aktuellen Cluster von Cassandra und seinen Objekten.
EXPAND - Erweitert die Ausgabe einer Abfrage vertikal.
EXIT - Mit diesem Befehl können Sie cqlsh beenden.
PAGING - Aktiviert oder deaktiviert das Abfrage-Paging.
SHOW - Zeigt die Details der aktuellen cqlsh-Sitzung an, z. B. Annahmen zur Cassandra-Version, zum Host oder zum Datentyp.
SOURCE - Führt eine Datei aus, die CQL-Anweisungen enthält.
TRACING - Aktiviert oder deaktiviert die Anforderungsverfolgung.

CQL-Datendefinitionsbefehle

CREATE KEYSPACE - Erstellt einen KeySpace in Cassandra.
USE - Stellt eine Verbindung zu einem erstellten KeySpace her.
ALTER KEYSPACE - Ändert die Eigenschaften eines KeySpace.
DROP KEYSPACE - Entfernt einen KeySpace
CREATE TABLE - Erstellt eine Tabelle in einem KeySpace.
ALTER TABLE - Ändert die Spalteneigenschaften einer Tabelle.
DROP TABLE - Entfernt eine Tabelle.
TRUNCATE - Entfernt alle Daten aus einer Tabelle.
CREATE INDEX - Definiert einen neuen Index für eine einzelne Spalte einer Tabelle.
DROP INDEX - Löscht einen benannten Index.

CQL-Datenmanipulationsbefehle

INSERT - Fügt Spalten für eine Zeile in einer Tabelle hinzu.
UPDATE - Aktualisiert eine Spalte einer Zeile.
DELETE - Löscht Daten aus einer Tabelle.
BATCH - Führt mehrere DML-Anweisungen gleichzeitig aus.

CQL-Klauseln

SELECT - Diese Klausel liest Daten aus einer Tabelle
WHERE - Die where-Klausel wird zusammen mit select zum Lesen bestimmter Daten verwendet.
ORDERBY - Die orderby-Klausel wird zusammen mit select verwendet, um bestimmte Daten in einer bestimmten Reihenfolge zu lesen.

Cassandra bietet zusätzlich zu CQL-Befehlen dokumentierte Shell-Befehle. Im Folgenden sind die von Cassandra dokumentierten Shell-Befehle aufgeführt.

Hilfe

Der Befehl HELP zeigt eine Zusammenfassung und eine kurze Beschreibung aller cqlsh-Befehle an. Im Folgenden wird die Verwendung des Hilfebefehls angegeben.

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

Erfassung

Dieser Befehl erfasst die Ausgabe eines Befehls und fügt ihn einer Datei hinzu. Schauen Sie sich beispielsweise den folgenden Code an, der die Ausgabe in eine Datei mit dem Namen erfasstOutputfile.

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

Wenn wir einen Befehl in das Terminal eingeben, wird die Ausgabe von der angegebenen Datei erfasst. Unten ist der verwendete Befehl und der Schnappschuss der Ausgabedatei angegeben.

cqlsh:tutorialspoint> select * from emp;

Sie können die Erfassung mit dem folgenden Befehl deaktivieren.

cqlsh:tutorialspoint> capture off;

Konsistenz

Dieser Befehl zeigt die aktuelle Konsistenzstufe an oder legt eine neue Konsistenzstufe fest.

cqlsh:tutorialspoint> CONSISTENCY
Current consistency level is 1.

Kopieren

Dieser Befehl kopiert Daten von und nach Cassandra in eine Datei. Im Folgenden finden Sie ein Beispiel zum Kopieren der genannten Tabelleemp in die Datei myfile.

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

Wenn Sie die angegebene Datei öffnen und überprüfen, finden Sie die kopierten Daten wie unten gezeigt.

Beschreiben

Dieser Befehl beschreibt den aktuellen Cluster von Cassandra und seinen Objekten. Die Varianten dieses Befehls werden unten erläutert.

Describe cluster - Dieser Befehl enthält Informationen zum 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- Dieser Befehl listet alle Schlüsselbereiche in einem Cluster auf. Im Folgenden wird die Verwendung dieses Befehls angegeben.

cqlsh:tutorialspoint> describe keyspaces;

system_traces system tp tutorialspoint

Describe tables- Dieser Befehl listet alle Tabellen in einem Schlüsselbereich auf. Im Folgenden wird die Verwendung dieses Befehls angegeben.

cqlsh:tutorialspoint> describe tables;
emp

Describe table- Dieser Befehl enthält die Beschreibung einer Tabelle. Im Folgenden wird die Verwendung dieses Befehls angegeben.

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);

Typ beschreiben

Mit diesem Befehl wird ein benutzerdefinierter Datentyp beschrieben. Im Folgenden wird die Verwendung dieses Befehls angegeben.

cqlsh:tutorialspoint> describe type card_details;

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

Typen beschreiben

Dieser Befehl listet alle benutzerdefinierten Datentypen auf. Im Folgenden wird die Verwendung dieses Befehls angegeben. Angenommen, es gibt zwei benutzerdefinierte Datentypen:card und card_details.

cqlsh:tutorialspoint> DESCRIBE TYPES;

card_details card

Erweitern

Dieser Befehl wird verwendet, um die Ausgabe zu erweitern. Bevor Sie diesen Befehl verwenden können, müssen Sie den Befehl expand aktivieren. Im Folgenden wird die Verwendung dieses Befehls angegeben.

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 - Sie können die Erweiterungsoption mit dem folgenden Befehl deaktivieren.

cqlsh:tutorialspoint> expand off;
Disabled Expanded output.

Ausgang

Dieser Befehl wird verwendet, um die cql-Shell zu beenden.

Show

Dieser Befehl zeigt die Details der aktuellen cqlsh-Sitzung an, z. B. Annahmen zur Cassandra-Version, zum Host oder zum Datentyp. Im Folgenden wird die Verwendung dieses Befehls angegeben.

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]

Quelle

Mit diesem Befehl können Sie die Befehle in einer Datei ausführen. Angenommen, unsere Eingabedatei lautet wie folgt:

Anschließend können Sie die Datei mit den Befehlen wie unten gezeigt ausführen.

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)

Erstellen eines Schlüsselraums mit Cqlsh

Ein Schlüsselraum in Cassandra ist ein Namespace, der die Datenreplikation auf Knoten definiert. Ein Cluster enthält einen Schlüsselbereich pro Knoten. Im Folgenden wird die Syntax zum Erstellen eines Schlüsselbereichs mithilfe der Anweisung angegebenCREATE KEYSPACE.

Syntax

CREATE KEYSPACE <identifier> WITH <properties>

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’;

Die Anweisung CREATE KEYSPACE hat zwei Eigenschaften: replication und durable_writes.

Reproduzieren

Die Replikationsoption besteht darin, die anzugeben Replica Placement strategyund die Anzahl der gewünschten Repliken. In der folgenden Tabelle sind alle Strategien zur Platzierung von Replikaten aufgeführt.

Strategiename	Beschreibung
Simple Strategy'	Gibt einen einfachen Replikationsfaktor für den Cluster an.
Network Topology Strategy	Mit dieser Option können Sie den Replikationsfaktor für jedes Rechenzentrum unabhängig festlegen.
Old Network Topology Strategy	Dies ist eine ältere Replikationsstrategie.

Mit dieser Option können Sie Cassandra anweisen, ob sie verwenden soll commitlogfür Updates auf dem aktuellen KeySpace. Diese Option ist nicht obligatorisch und standardmäßig auf true gesetzt.

Beispiel

Im Folgenden finden Sie ein Beispiel für die Erstellung eines KeySpace.

Hier erstellen wir einen KeySpace mit dem Namen TutorialsPoint.
Wir verwenden die erste Strategie zur Platzierung von Replikaten, d. H. Simple Strategy.
Und wir wählen den Replikationsfaktor für 1 replica.

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

Überprüfung

Mit dem Befehl können Sie überprüfen, ob die Tabelle erstellt wurde oder nicht Describe. Wenn Sie diesen Befehl über Keyspaces verwenden, werden alle wie unten gezeigt erstellten Keyspaces angezeigt.

cqlsh> DESCRIBE keyspaces;

tutorialspoint system system_traces

Hier können Sie den neu erstellten KeySpace beobachten tutorialspoint.

Durable_writes

Standardmäßig sind die Eigenschaften von durable_writes einer Tabelle auf festgelegt true,es kann jedoch auf false gesetzt werden. Sie können diese Eigenschaft nicht auf festlegensimplex strategy.

Beispiel

Das folgende Beispiel zeigt die Verwendung der Eigenschaft für dauerhafte Schreibvorgänge.

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

Überprüfung

Sie können überprüfen, ob die Eigenschaft durable_writes von test KeySpace auf false gesetzt wurde, indem Sie den System Keyspace abfragen. Diese Abfrage gibt Ihnen alle KeySpaces mit ihren Eigenschaften.

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)

Hier können Sie beobachten, dass die Eigenschaft durable_writes des Tests KeySpace auf false gesetzt wurde.

Verwenden eines Schlüsselraums

Sie können einen erstellten KeySpace mit dem Schlüsselwort verwenden USE. Die Syntax lautet wie folgt:

Syntax:USE <identifier>

Beispiel

Im folgenden Beispiel verwenden wir den KeySpace tutorialspoint.

cqlsh> USE tutorialspoint;
cqlsh:tutorialspoint>

Erstellen eines Schlüsselraums mithilfe der Java-API

Sie können einen Schlüsselraum mit dem erstellen execute() Methode von SessionKlasse. Führen Sie die folgenden Schritte aus, um mithilfe der Java-API einen Schlüsselbereich zu erstellen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie zunächst eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

//Creating Cluster.Builder object

Cluster.Builder builder1 = Cluster.builder();

Fügen Sie mit einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.Builder.

//Adding contact point to the Cluster.Builder object

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

Erstellen Sie mit dem neuen Builder-Objekt ein Cluster-Objekt. Dazu haben Sie eine Methode namensbuild() in dem Cluster.BuilderKlasse. Der folgende Code zeigt, wie Sie ein Clusterobjekt erstellen.

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

Sie können ein Clusterobjekt in einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz von Session Objekt mit dem connect() Methode von Cluster Klasse wie unten gezeigt.

Session session = cluster.connect( );

Diese Methode erstellt eine neue Sitzung und initialisiert sie. Wenn Sie bereits einen Schlüsselraum haben, können Sie ihn auf den vorhandenen festlegen, indem Sie den Schlüsselraumnamen im Zeichenfolgenformat wie unten gezeigt an diese Methode übergeben.

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

Schritt 3: Abfrage ausführen

Sie können ausführen CQL Abfragen mit dem execute() Methode von SessionKlasse. Übergeben Sie die Abfrage entweder im Zeichenfolgenformat oder alsStatement Klassenobjekt zum execute()Methode. Was auch immer Sie im String-Format an diese Methode übergeben, wird auf dem ausgeführtcqlsh.

In diesem Beispiel erstellen wir einen KeySpace mit dem Namen tp. Wir verwenden die erste Strategie zur Platzierung von Replikaten, dh die einfache Strategie, und wählen den Replikationsfaktor für 1 Replikat aus.

Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

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

Schritt 4: Verwenden Sie den KeySpace

Sie können einen erstellten KeySpace mit der Methode execute () verwenden, wie unten gezeigt.

execute(“ USE tp ” );

Im Folgenden finden Sie das vollständige Programm zum Erstellen und Verwenden eines Schlüsselbereichs in Cassandra mithilfe der 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"); 
   }
}

Speichern Sie das obige Programm mit dem Klassennamen gefolgt von .java und navigieren Sie zu dem Speicherort, an dem es gespeichert ist. Kompilieren Sie das Programm und führen Sie es wie unten gezeigt aus.

$javac Create_KeySpace.java
$java Create_KeySpace

Unter normalen Bedingungen wird die folgende Ausgabe erzeugt:

Keyspace created

Ändern eines KeySpace

Mit ALTER KEYSPACE können Eigenschaften wie die Anzahl der Replikate und die dauerhaften Schreibvorgänge eines KeySpace geändert werden. Unten ist die Syntax dieses Befehls angegeben.

Syntax

ALTER KEYSPACE <identifier> WITH <properties>

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

Die Eigenschaften von ALTER KEYSPACEsind gleich wie CREATE KEYSPACE. Es hat zwei Eigenschaften:replication und durable_writes.

Reproduzieren

Die Replikationsoption gibt die Replikationsplatzierungsstrategie und die Anzahl der gewünschten Replikate an.

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};

Ändern von Durable_writes

Sie können auch die Eigenschaft durable_writes eines KeySpace ändern. Im Folgenden ist die Eigenschaft durable_writes von angegebentest 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;

Wenn Sie die Eigenschaften von KeySpaces überprüfen, wird erneut die folgende Ausgabe ausgegeben.

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)

Ändern eines Schlüsselraums mithilfe der Java-API

Sie können einen Schlüsselbereich mit dem ändern execute() Methode von SessionKlasse. Führen Sie die folgenden Schritte aus, um einen Schlüsselbereich mithilfe der Java-API zu ändern

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie zunächst eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können das Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz von Session Objekt mit dem connect() Methode von ClusterKlasse wie unten gezeigt.

Session session = cluster.connect( );

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

Schritt 3: Abfrage ausführen

Sie können CQL-Abfragen mit der Methode execute () der Session-Klasse ausführen. Übergeben Sie die Abfrage entweder im Zeichenfolgenformat oder alsStatementKlassenobjekt für die Methode execute (). Was auch immer Sie im String-Format an diese Methode übergeben, wird auf dem ausgeführtcqlsh.

In diesem Beispiel

Wir ändern einen Schlüsselraum mit dem Namen tp. Wir ändern die Replikationsoption von "Einfache Strategie" in "Netzwerktopologiestrategie".
Wir verändern das durable_writes zu falsch

Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

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

Im Folgenden finden Sie das vollständige Programm zum Erstellen und Verwenden eines Schlüsselbereichs in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Alter_KeySpace.java
$java Alter_KeySpace

Unter normalen Bedingungen wird die folgende Ausgabe erzeugt:

Keyspace Altered

Löschen eines Schlüsselraums

Sie können einen KeySpace mit dem Befehl löschen DROP KEYSPACE. Im Folgenden wird die Syntax zum Löschen eines KeySpace angegeben.

Syntax

DROP KEYSPACE <identifier>

DROP KEYSPACE “KeySpace name”

Beispiel

Der folgende Code löscht den Schlüsselraum tutorialspoint.

cqlsh> DROP KEYSPACE tutorialspoint;

Überprüfung

Überprüfen Sie die Schlüsselbereiche mit dem Befehl Describe und prüfen Sie, ob die Tabelle wie unten gezeigt gelöscht wird.

cqlsh> DESCRIBE keyspaces;

system system_traces

Da wir den Schlüsselbereich-Tutorialpunkt gelöscht haben, finden Sie ihn nicht in der Schlüsselbereichsliste.

Löschen eines Schlüsselraums mithilfe der Java-API

Sie können einen Schlüsselbereich mit der Methode execute () der Session-Klasse erstellen. Führen Sie die folgenden Schritte aus, um einen Schlüsselbereich mithilfe der Java-API zu löschen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie zunächst eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können ein Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

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

Schritt 3: Abfrage ausführen

Sie können CQL-Abfragen mit der Methode execute () der Session-Klasse ausführen. Übergeben Sie die Abfrage entweder im Zeichenfolgenformat oder als Anweisungsklassenobjekt an die Methode execute (). Was auch immer Sie im String-Format an diese Methode übergeben, wird auf dem cqlsh ausgeführt.

Im folgenden Beispiel löschen wir einen Schlüsselraum mit dem Namen tp. Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

String query = "DROP KEYSPACE tp; ";

session.execute(query);

Im Folgenden finden Sie das vollständige Programm zum Erstellen und Verwenden eines Schlüsselbereichs in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Delete_KeySpace.java
$java Delete_KeySpace

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Keyspace deleted

Erstellen einer Tabelle

Mit dem Befehl können Sie eine Tabelle erstellen CREATE TABLE. Im Folgenden wird die Syntax zum Erstellen einer Tabelle angegeben.

Syntax

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

Eine Spalte definieren

Sie können eine Spalte wie unten gezeigt definieren.

column name1 data type,
column name2 data type,

example:

age int,
name text

Primärschlüssel

Der Primärschlüssel ist eine Spalte, mit der eine Zeile eindeutig identifiziert wird. Daher ist beim Erstellen einer Tabelle das Definieren eines Primärschlüssels obligatorisch. Ein Primärschlüssel besteht aus einer oder mehreren Spalten einer Tabelle. Sie können einen Primärschlüssel einer Tabelle wie unten gezeigt definieren.

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)
   )

Beispiel

Im Folgenden finden Sie ein Beispiel zum Erstellen einer Tabelle in Cassandra mit cqlsh. Hier sind wir -

Verwenden des Schlüsselbereichs tutorialspoint
Erstellen einer Tabelle mit dem Namen emp

Es enthält Details wie Name des Mitarbeiters, ID, Stadt, Gehalt und Telefonnummer. Mitarbeiter-ID ist der Primärschlüssel.

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
   );

Überprüfung

Die select-Anweisung gibt Ihnen das Schema. Überprüfen Sie die Tabelle mit der select-Anweisung wie unten gezeigt.

cqlsh:tutorialspoint> select * from emp;

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

(0 rows)

Hier können Sie die Tabelle beobachten, die mit den angegebenen Spalten erstellt wurde. Da wir den Schlüsselbereich-Tutorialpunkt gelöscht haben, finden Sie ihn nicht in der Schlüsselbereichsliste.

Erstellen einer Tabelle mit der Java-API

Sie können eine Tabelle mit der Methode execute () der Session-Klasse erstellen. Führen Sie die folgenden Schritte aus, um eine Tabelle mit der Java-API zu erstellen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie zunächst eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können ein Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit dem connect() Methode von Cluster Klasse wie unten gezeigt.

Session session = cluster.connect( );

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

Hier verwenden wir den genannten Schlüsselraum tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

Im folgenden Beispiel erstellen wir eine Tabelle mit dem Namen emp. Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

//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);

Im Folgenden finden Sie das vollständige Programm zum Erstellen und Verwenden eines Schlüsselbereichs in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Create_Table.java
$java Create_Table

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Table created

Eine Tabelle ändern

Sie können eine Tabelle mit dem Befehl ändern ALTER TABLE. Im Folgenden wird die Syntax zum Erstellen einer Tabelle angegeben.

Syntax

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

Mit dem Befehl ALTER können Sie die folgenden Vorgänge ausführen:

Fügen Sie eine Spalte hinzu
Löschen Sie eine Spalte

Hinzufügen einer Spalte

Mit dem Befehl ALTER können Sie einer Tabelle eine Spalte hinzufügen. Beim Hinzufügen von Spalten müssen Sie darauf achten, dass der Spaltenname nicht mit den vorhandenen Spaltennamen in Konflikt steht und dass die Tabelle nicht mit einer kompakten Speicheroption definiert ist. Im Folgenden wird die Syntax zum Hinzufügen einer Spalte zu einer Tabelle angegeben.

ALTER TABLE table name
ADD  new column datatype;

Example

Im Folgenden finden Sie ein Beispiel zum Hinzufügen einer Spalte zu einer vorhandenen Tabelle. Hier fügen wir eine Spalte mit dem Namen hinzuemp_email des Textdatentyps zu der genannten Tabelle emp.

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

Verification

Verwenden Sie die SELECT-Anweisung, um zu überprüfen, ob die Spalte hinzugefügt wurde oder nicht. Hier können Sie die neu hinzugefügte Spalte emp_email beobachten.

cqlsh:tutorialspoint> select * from emp;

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

Eine Spalte löschen

Mit dem Befehl ALTER können Sie eine Spalte aus einer Tabelle löschen. Überprüfen Sie vor dem Löschen einer Spalte aus einer Tabelle, ob die Tabelle nicht mit einer kompakten Speicheroption definiert ist. Im Folgenden wird die Syntax zum Löschen einer Spalte aus einer Tabelle mit dem Befehl ALTER angegeben.

ALTER table name
DROP column name;

Example

Im Folgenden finden Sie ein Beispiel zum Löschen einer Spalte aus einer Tabelle. Hier löschen wir die genannte Spalteemp_email.

cqlsh:tutorialspoint> ALTER TABLE emp DROP emp_email;

Verification

Überprüfen Sie, ob die Spalte mit dem gelöscht wird select Aussage, wie unten gezeigt.

cqlsh:tutorialspoint> select * from emp;

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

Schon seit emp_email Spalte wurde gelöscht, Sie können sie nicht mehr finden.

Ändern einer Tabelle mithilfe der Java-API

Sie können eine Tabelle mit der Methode execute () der Session-Klasse erstellen. Führen Sie die folgenden Schritte aus, um eine Tabelle mithilfe der Java-API zu ändern.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie zunächst eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können ein Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

Diese Methode erstellt eine neue Sitzung und initialisiert sie. Wenn Sie bereits über einen Schlüsselbereich verfügen, können Sie ihn auf den vorhandenen festlegen, indem Sie den KeySpace-Namen im Zeichenfolgenformat wie unten gezeigt an diese Methode übergeben.

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

Hier verwenden wir den KeySpace mit dem Namen tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

Schritt 3: Abfrage ausführen

Im folgenden Beispiel fügen wir einer Tabelle mit dem Namen eine Spalte hinzu emp. Dazu müssen Sie die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

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

Im Folgenden finden Sie das vollständige Programm zum Hinzufügen einer Spalte zu einer vorhandenen Tabelle.

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");
   }
}

$javac Add_Column.java
$java Add_Column

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Column added

Eine Spalte löschen

Im Folgenden finden Sie das vollständige Programm zum Löschen einer Spalte aus einer vorhandenen Tabelle.

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");
   }
 }

$javac Delete_Column.java
$java Delete_Column

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Column deleted

Eine Tabelle löschen

Sie können eine Tabelle mit dem Befehl löschen Drop Table. Die Syntax lautet wie folgt:

Syntax

DROP TABLE <tablename>

Beispiel

Der folgende Code löscht eine vorhandene Tabelle aus einem KeySpace.

cqlsh:tutorialspoint> DROP TABLE emp;

Überprüfung

Verwenden Sie den Befehl Beschreiben, um zu überprüfen, ob die Tabelle gelöscht wurde oder nicht. Da die emp-Tabelle gelöscht wurde, finden Sie sie nicht in der Liste der Spaltenfamilien.

cqlsh:tutorialspoint> DESCRIBE COLUMNFAMILIES;
employee

Löschen einer Tabelle mit der Java-API

Sie können eine Tabelle mit der Methode execute () der Session-Klasse löschen. Führen Sie die folgenden Schritte aus, um eine Tabelle mithilfe der Java-API zu löschen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie zunächst eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt -

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

Fügen Sie mit einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können ein Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

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

Hier verwenden wir den genannten Schlüsselraum tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

Im folgenden Beispiel löschen wir eine Tabelle mit dem Namen emp. Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

// Query

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

Im Folgenden finden Sie das vollständige Programm zum Löschen einer Tabelle in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Drop_Table.java
$java Drop_Table

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Table dropped

Eine Tabelle abschneiden

Sie können eine Tabelle mit dem Befehl TRUNCATE abschneiden. Wenn Sie eine Tabelle abschneiden, werden alle Zeilen der Tabelle dauerhaft gelöscht. Unten ist die Syntax dieses Befehls angegeben.

Syntax

TRUNCATE <tablename>

Beispiel

Nehmen wir an, es gibt eine Tabelle namens student mit den folgenden Daten.

s_id	s_name	s_branch	s_aggregate
1	RAM	ES	70
2	rahman	EEE	75
3	Robbin	Mech	72

Wenn Sie die select-Anweisung ausführen, um die Tabelle abzurufen student, Sie erhalten die folgende Ausgabe.

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)

Schneiden Sie nun die Tabelle mit dem Befehl TRUNCATE ab.

cqlsh:tp> TRUNCATE student;

Überprüfung

Überprüfen Sie, ob die Tabelle abgeschnitten ist, indem Sie die ausführen selectErklärung. Unten ist die Ausgabe der select-Anweisung in der Schülertabelle nach dem Abschneiden angegeben.

cqlsh:tp> select * from student;

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

(0 rows)

Abschneiden einer Tabelle mithilfe der Java-API

Sie können eine Tabelle mit der Methode execute () der Session-Klasse abschneiden. Führen Sie die folgenden Schritte aus, um eine Tabelle abzuschneiden.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie zunächst eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können ein Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen eines Sitzungsobjekts

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

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

Hier verwenden wir den Schlüsselraum tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

Schritt 3: Abfrage ausführen

Im folgenden Beispiel kürzen wir eine Tabelle mit dem Namen emp. Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und an die übergebenexecute() Methode wie unten gezeigt.

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

Im Folgenden finden Sie das vollständige Programm zum Abschneiden einer Tabelle in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Truncate_Table.java
$java Truncate_Table

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Table truncated

Erstellen eines Index mit Cqlsh

Mit dem Befehl können Sie in Cassandra einen Index erstellen CREATE INDEX. Die Syntax lautet wie folgt:

CREATE INDEX <identifier> ON <tablename>

Im Folgenden finden Sie ein Beispiel zum Erstellen eines Index für eine Spalte. Hier erstellen wir einen Index für eine Spalte 'emp_name' in einer Tabelle mit dem Namen emp.

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

Erstellen eines Index mit der Java-API

Sie können einen Index für eine Spalte einer Tabelle mit der Methode execute () der Session-Klasse erstellen. Führen Sie die folgenden Schritte aus, um einen Index für eine Spalte in einer Tabelle zu erstellen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie zunächst eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können das Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der connect () -Methode von Cluster Klasse wie unten gezeigt.

Session session = cluster.connect( );

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

Hier verwenden wir den aufgerufenen KeySpace tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

Im folgenden Beispiel erstellen wir einen Index für eine Spalte mit dem Namen emp_name in einer Tabelle mit dem Namen emp. Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

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

Im Folgenden finden Sie das vollständige Programm zum Erstellen eines Index einer Spalte in einer Tabelle in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Create_Index.java
$java Create_Index

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Index created

Index löschen

Sie können einen Index mit dem Befehl löschen DROP INDEX. Die Syntax lautet wie folgt:

DROP INDEX <identifier>

Im Folgenden finden Sie ein Beispiel zum Löschen eines Index einer Spalte in einer Tabelle. Hier legen wir den Index des Spaltennamens in der Tabelle emp ab.

cqlsh:tp> drop index name;

Löschen eines Index mithilfe der Java-API

Sie können einen Index einer Tabelle mit der execute () -Methode der Session-Klasse löschen. Führen Sie die folgenden Schritte aus, um einen Index aus einer Tabelle zu löschen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.Builder object. Diese Methode gibt zurückCluster.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();

Sie können ein Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

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

Hier verwenden wir den genannten KeySpace tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

Im folgenden Beispiel löschen wir einen Indexnamen von empTabelle. Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

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

Im Folgenden finden Sie das vollständige Programm zum Löschen eines Index in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Drop_index.java
$java Drop_index

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Index dropped

Stapelanweisungen verwenden

Verwenden von BATCH,Sie können mehrere Änderungsanweisungen (Einfügen, Aktualisieren, Löschen) gleichzeitig ausführen. Die Syntax lautet wie folgt:

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

Beispiel

Angenommen, in Cassandra gibt es eine Tabelle namens emp mit den folgenden Daten:

emp_id	emp_name	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	Robin	Delhi	9848022339	50000
3	rahman	Chennai	9848022330	45000

In diesem Beispiel führen wir die folgenden Operationen aus:

Fügen Sie eine neue Zeile mit den folgenden Details ein (4, rajeev, pune, 9848022331, 30000).
Aktualisieren Sie das Gehalt des Mitarbeiters mit der Zeilen-ID 3 auf 50000.
Löschen Sie die Stadt des Mitarbeiters mit der Zeilen-ID 2.

Verwenden Sie den folgenden BATCH-Befehl, um die oben genannten Vorgänge auf einmal auszuführen:

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;

Überprüfung

Überprüfen Sie die Tabelle nach dem Vornehmen von Änderungen mit der SELECT-Anweisung. Es sollte die folgende Ausgabe erzeugen -

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)

Hier können Sie die Tabelle mit geänderten Daten beobachten.

Stapelanweisungen mit Java-API

Stapelanweisungen können mithilfe der execute () -Methode der Session-Klasse programmgesteuert in eine Tabelle geschrieben werden. Führen Sie die folgenden Schritte aus, um mehrere Anweisungen mithilfe der Batch-Anweisung mithilfe der Java-API auszuführen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.Builder.

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

Erstellen Sie mit dem neuen Builder-Objekt ein Cluster-Objekt. Dazu haben Sie eine Methode namensbuild() in dem Cluster.BuilderKlasse. Verwenden Sie den folgenden Code, um das Clusterobjekt zu erstellen:

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

Sie können das Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

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

Hier verwenden wir den genannten KeySpace tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

In diesem Beispiel führen wir die folgenden Operationen aus:

Fügen Sie eine neue Zeile mit den folgenden Details ein (4, rajeev, pune, 9848022331, 30000).
Aktualisieren Sie das Gehalt des Mitarbeiters mit der Zeilen-ID 3 auf 50000.
Löschen Sie die Stadt des Mitarbeiters mit der Zeilen-ID 2.

Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

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;”;

Im Folgenden finden Sie das vollständige Programm zum gleichzeitigen Ausführen mehrerer Anweisungen für eine Tabelle in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Batch.java
$java Batch

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Changes done

Daten in einer Tabelle erstellen

Mit dem Befehl können Sie Daten in die Spalten einer Zeile in einer Tabelle einfügen INSERT. Im Folgenden wird die Syntax zum Erstellen von Daten in einer Tabelle angegeben.

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

Beispiel

Nehmen wir an, es gibt eine Tabelle namens emp mit Spalten (emp_id, emp_name, emp_city, emp_phone, emp_sal) und Sie müssen die folgenden Daten in die einfügen emp Tabelle.

emp_id	emp_name	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	Robin	Hyderabad	9848022339	40000
3	rahman	Chennai	9848022330	45000

Verwenden Sie die folgenden Befehle, um die Tabelle mit den erforderlichen Daten zu füllen.

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);

Überprüfung

Verwenden Sie nach dem Einfügen von Daten die Anweisung SELECT, um zu überprüfen, ob die Daten eingefügt wurden oder nicht. Wenn Sie die Tabelle emp mit der Anweisung SELECT überprüfen, erhalten Sie die folgende Ausgabe.

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)

Hier können Sie beobachten, dass die Tabelle mit den von uns eingefügten Daten gefüllt ist.

Erstellen von Daten mit der Java-API

Sie können Daten in einer Tabelle mit der Methode execute () der Session-Klasse erstellen. Führen Sie die folgenden Schritte aus, um mithilfe der Java-API Daten in einer Tabelle zu erstellen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können ein Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

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

Hier verwenden wir den aufgerufenen KeySpace tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

Im folgenden Beispiel fügen wir Daten in eine aufgerufene Tabelle ein emp. Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben.

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);

Im Folgenden finden Sie das vollständige Programm zum Einfügen von Daten in eine Tabelle in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Create_Data.java
$java Create_Data

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Data created

Aktualisieren von Daten in einer Tabelle

UPDATEist der Befehl zum Aktualisieren von Daten in einer Tabelle. Die folgenden Schlüsselwörter werden beim Aktualisieren von Daten in einer Tabelle verwendet:

Where - Mit dieser Klausel wird die zu aktualisierende Zeile ausgewählt.
Set - Legen Sie den Wert mit diesem Schlüsselwort fest.
Must - Beinhaltet alle Spalten, aus denen der Primärschlüssel besteht.

Wenn beim Aktualisieren von Zeilen eine bestimmte Zeile nicht verfügbar ist, erstellt UPDATE eine neue Zeile. Unten ist die Syntax des UPDATE-Befehls angegeben -

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

Beispiel

Angenommen, es gibt eine Tabelle mit dem Namen emp. Diese Tabelle speichert die Details der Mitarbeiter eines bestimmten Unternehmens und enthält die folgenden Details:

emp_id	emp_name	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	Robin	Hyderabad	9848022339	40000
3	rahman	Chennai	9848022330	45000

Lassen Sie uns jetzt emp_city of robin nach Delhi und sein Gehalt auf 50000 aktualisieren. Nachfolgend finden Sie die Abfrage, um die erforderlichen Aktualisierungen durchzuführen.

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

Überprüfung

Verwenden Sie die SELECT-Anweisung, um zu überprüfen, ob die Daten aktualisiert wurden oder nicht. Wenn Sie die Tabelle emp mit der Anweisung SELECT überprüfen, wird die folgende Ausgabe ausgegeben.

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)

Hier können Sie beobachten, dass die Tabellendaten aktualisiert wurden.

Aktualisieren von Daten mithilfe der Java-API

Sie können Daten in einer Tabelle mit der Methode execute () der Sitzungsklasse aktualisieren. Führen Sie die folgenden Schritte aus, um Daten in einer Tabelle mithilfe der Java-API zu aktualisieren.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können das Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

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

Hier verwenden wir den genannten KeySpace tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

Im folgenden Beispiel aktualisieren wir die emp-Tabelle. Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und wie unten gezeigt an die Methode execute () übergeben:

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

Im Folgenden finden Sie das vollständige Programm zum Aktualisieren von Daten in einer Tabelle mithilfe der Java-API.

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");
   }
 }

$javac Update_Data.java
$java Update_Data

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Data updated

Lesen von Daten mit der Select-Klausel

Die SELECT-Klausel wird verwendet, um Daten aus einer Tabelle in Cassandra zu lesen. Mit dieser Klausel können Sie eine ganze Tabelle, eine einzelne Spalte oder eine bestimmte Zelle lesen. Im Folgenden ist die Syntax der SELECT-Klausel angegeben.

SELECT FROM <tablename>

Beispiel

Angenommen, im Schlüsselbereich befindet sich eine Tabelle mit dem Namen emp mit folgenden Angaben -

emp_id	emp_name	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	Robin	Null	9848022339	50000
3	rahman	Chennai	9848022330	50000
4	Rajeev	Pune	9848022331	30000

Das folgende Beispiel zeigt, wie eine ganze Tabelle mit der SELECT-Klausel gelesen wird. Hier lesen wir eine Tabelle namensemp.

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)

Erforderliche Spalten lesen

Das folgende Beispiel zeigt, wie eine bestimmte Spalte in einer Tabelle gelesen wird.

cqlsh:tutorialspoint> SELECT emp_name, emp_sal from emp;

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

Wo Klausel

Mit der WHERE-Klausel können Sie die erforderlichen Spalten einschränken. Die Syntax lautet wie folgt:

SELECT FROM <table name> WHERE <condition>;

Note - Eine WHERE-Klausel kann nur für Spalten verwendet werden, die Teil des Primärschlüssels sind oder über einen Sekundärindex verfügen.

Im folgenden Beispiel lesen wir die Details eines Mitarbeiters mit einem Gehalt von 50000. Setzen Sie zunächst den Sekundärindex auf die Spalte 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

Lesen von Daten mit der Java-API

Sie können Daten aus einer Tabelle mit der Methode execute () der Session-Klasse lesen. Führen Sie die folgenden Schritte aus, um mehrere Anweisungen mithilfe der Batch-Anweisung mithilfe der Java-API auszuführen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können das Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

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

Hier verwenden wir den aufgerufenen KeySpace tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

In diesem Beispiel rufen wir die Daten von ab empTabelle. Speichern Sie die Abfrage in einer Zeichenfolge und übergeben Sie sie wie unten gezeigt an die Methode execute () der Sitzungsklasse.

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

Führen Sie die Abfrage mit der Methode execute () der Sitzungsklasse aus.

Schritt 4: Holen Sie sich das ResultSet-Objekt

Die ausgewählten Abfragen geben das Ergebnis in Form von a zurück ResultSet Objekt, speichern Sie daher das Ergebnis im Objekt von RESULTSET Klasse wie unten gezeigt.

ResultSet result = session.execute( );

Im Folgenden finden Sie das vollständige Programm zum Lesen von Daten aus einer Tabelle.

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());
   }
}

$javac Read_Data.java
$java Read_Data

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

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

Lesen von Daten mit der Select-Klausel

SELECT FROM <tablename>

Beispiel

Angenommen, im Schlüsselbereich befindet sich eine Tabelle mit dem Namen emp mit folgenden Angaben -

emp_id	emp_name	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	Robin	Null	9848022339	50000
3	rahman	Chennai	9848022330	50000
4	Rajeev	Pune	9848022331	30000

Das folgende Beispiel zeigt, wie eine ganze Tabelle mit der SELECT-Klausel gelesen wird. Hier lesen wir eine Tabelle namensemp.

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)

Erforderliche Spalten lesen

Das folgende Beispiel zeigt, wie eine bestimmte Spalte in einer Tabelle gelesen wird.

cqlsh:tutorialspoint> SELECT emp_name, emp_sal from emp;

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

Wo Klausel

Mit der WHERE-Klausel können Sie die erforderlichen Spalten einschränken. Die Syntax lautet wie folgt:

SELECT FROM <table name> WHERE <condition>;

Note - Eine WHERE-Klausel kann nur für Spalten verwendet werden, die Teil des Primärschlüssels sind oder über einen Sekundärindex verfügen.

Im folgenden Beispiel lesen wir die Details eines Mitarbeiters mit einem Gehalt von 50000. Setzen Sie zunächst den Sekundärindex auf die Spalte 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

Lesen von Daten mit der Java-API

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können das Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect( );

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

Hier verwenden wir den aufgerufenen KeySpace tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

In diesem Beispiel rufen wir die Daten von ab empTabelle. Speichern Sie die Abfrage in einer Zeichenfolge und übergeben Sie sie wie unten gezeigt an die Methode execute () der Sitzungsklasse.

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

Führen Sie die Abfrage mit der Methode execute () der Sitzungsklasse aus.

Schritt 4: Holen Sie sich das ResultSet-Objekt

Die ausgewählten Abfragen geben das Ergebnis in Form von a zurück ResultSet Objekt, speichern Sie daher das Ergebnis im Objekt von RESULTSET Klasse wie unten gezeigt.

ResultSet result = session.execute( );

Im Folgenden finden Sie das vollständige Programm zum Lesen von Daten aus einer Tabelle.

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());
   }
}

$javac Read_Data.java
$java Read_Data

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

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

Daten aus einer Tabelle löschen

Mit dem Befehl können Sie Daten aus einer Tabelle löschen DELETE. Die Syntax lautet wie folgt:

DELETE FROM <identifier> WHERE <condition>;

Beispiel

Nehmen wir an, in Cassandra gibt es einen Tisch namens emp mit folgenden Daten -

emp_id	emp_name	emp_city	emp_phone	emp_sal
1	RAM	Hyderabad	9848022338	50000
2	Robin	Hyderabad	9848022339	40000
3	rahman	Chennai	9848022330	45000

Die folgende Anweisung löscht die Spalte emp_sal der letzten Zeile -

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

Überprüfung

Verwenden Sie die SELECT-Anweisung, um zu überprüfen, ob die Daten gelöscht wurden oder nicht. Wenn Sie die emp-Tabelle mit SELECT überprüfen, wird die folgende Ausgabe ausgegeben:

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)

Da wir das Gehalt von Rahman gelöscht haben, werden Sie anstelle des Gehalts einen Nullwert beobachten.

Löschen einer gesamten Zeile

Der folgende Befehl löscht eine ganze Zeile aus einer Tabelle.

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

Überprüfung

Verwenden Sie die SELECT-Anweisung, um zu überprüfen, ob die Daten gelöscht wurden oder nicht. Wenn Sie die emp-Tabelle mit SELECT überprüfen, wird die folgende Ausgabe ausgegeben:

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)

Da wir die letzte Zeile gelöscht haben, sind nur noch zwei Zeilen in der Tabelle vorhanden.

Daten mit der Java-API löschen

Sie können Daten in einer Tabelle mit der Methode execute () der Sitzungsklasse löschen. Führen Sie die folgenden Schritte aus, um Daten mithilfe der Java-API aus einer Tabelle zu löschen.

Schritt 1: Erstellen Sie ein Clusterobjekt

Erstellen Sie eine Instanz von Cluster.builder Klasse von com.datastax.driver.core Paket wie unten gezeigt.

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

Fügen Sie einen Kontaktpunkt (IP-Adresse des Knotens) hinzu addContactPoint() Methode von Cluster.BuilderObjekt. Diese Methode gibt zurückCluster.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();

Sie können das Clusterobjekt mit einer einzelnen Codezeile erstellen, wie unten gezeigt.

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

Schritt 2: Erstellen Sie ein Sitzungsobjekt

Erstellen Sie eine Instanz des Sitzungsobjekts mit der Methode connect () der Cluster-Klasse (siehe unten).

Session session = cluster.connect();

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

Hier verwenden wir den aufgerufenen KeySpace tp. Erstellen Sie daher das Sitzungsobjekt wie unten gezeigt.

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

Schritt 3: Abfrage ausführen

Im folgenden Beispiel löschen wir Daten aus einer Tabelle mit dem Namen emp. Sie müssen die Abfrage in einer Zeichenfolgenvariablen speichern und an die übergeben execute() Methode wie unten gezeigt.

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

Im Folgenden finden Sie das vollständige Programm zum Löschen von Daten aus einer Tabelle in Cassandra mithilfe der Java-API.

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");
   }
}

$javac Delete_Data.java
$java Delete_Data

Unter normalen Bedingungen sollte die folgende Ausgabe erzeugt werden:

Data deleted

CQL bietet eine Vielzahl integrierter Datentypen, einschließlich Sammlungstypen. Neben diesen Datentypen können Benutzer auch ihre eigenen benutzerdefinierten Datentypen erstellen. Die folgende Tabelle enthält eine Liste der in CQL verfügbaren integrierten Datentypen.

Datentyp	Konstanten	Beschreibung
ASCII	Saiten	Repräsentiert die ASCII-Zeichenfolge
Bigint	Bigint	Repräsentiert eine 64-Bit-Signatur
blob	Blobs	Repräsentiert beliebige Bytes
Boolescher Wert	Boolesche Werte	Repräsentiert wahr oder falsch
counter	ganze Zahlen	Repräsentiert die Zählerspalte
Dezimal	ganze Zahlen, schwebt	Stellt eine Dezimalzahl mit variabler Genauigkeit dar
doppelt	ganze Zahlen	Repräsentiert 64-Bit-IEEE-754-Gleitkomma
schweben	ganze Zahlen, schwebt	Repräsentiert 32-Bit-IEEE-754-Gleitkomma
inet	Saiten	Repräsentiert eine IP-Adresse, IPv4 oder IPv6
int	ganze Zahlen	Repräsentiert 32-Bit-Int
Text	Saiten	Repräsentiert eine UTF8-codierte Zeichenfolge
timestamp	ganze Zahlen, Strings	Stellt einen Zeitstempel dar
timeuuid	uuids	Repräsentiert die UUID vom Typ 1
uuid	uuids	Repräsentiert Typ 1 oder Typ 4
		UUID
varchar	Saiten	Repräsentiert eine uTF8-codierte Zeichenfolge
varint	ganze Zahlen	Repräsentiert eine Ganzzahl mit beliebiger Genauigkeit

Sammlungsarten

Cassandra Query Language bietet auch eine Sammlung von Datentypen. Die folgende Tabelle enthält eine Liste der in CQL verfügbaren Sammlungen.

Sammlung	Beschreibung
Liste	Eine Liste ist eine Sammlung von einem oder mehreren geordneten Elementen.
Karte	Eine Karte ist eine Sammlung von Schlüssel-Wert-Paaren.
einstellen	Ein Set ist eine Sammlung von einem oder mehreren Elementen.

Benutzerdefinierte Datentypen

Cqlsh bietet Benutzern die Möglichkeit, ihre eigenen Datentypen zu erstellen. Im Folgenden sind die Befehle aufgeführt, die beim Umgang mit benutzerdefinierten Datentypen verwendet werden.

CREATE TYPE - Erstellt einen benutzerdefinierten Datentyp.
ALTER TYPE - Ändert einen benutzerdefinierten Datentyp.
DROP TYPE - Löscht einen benutzerdefinierten Datentyp.
DESCRIBE TYPE - Beschreibt einen benutzerdefinierten Datentyp.
DESCRIBE TYPES - Beschreibt benutzerdefinierte Datentypen.

CQL bietet die Möglichkeit, Sammlungsdatentypen zu verwenden. Mit diesen Sammlungstypen können Sie mehrere Werte in einer einzigen Variablen speichern. In diesem Kapitel wird die Verwendung von Sammlungen in Cassandra erläutert.

Liste

Liste wird in den Fällen verwendet, in denen

die Reihenfolge der Elemente ist beizubehalten, und
Ein Wert ist mehrfach zu speichern.

Sie können die Werte eines Listendatentyps anhand des Index der Elemente in der Liste abrufen.

Erstellen einer Tabelle mit Liste

Im Folgenden finden Sie ein Beispiel zum Erstellen einer Beispieltabelle mit zwei Spalten, Name und E-Mail. Um mehrere E-Mails zu speichern, verwenden wir list.

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

Einfügen von Daten in eine Liste

Geben Sie beim Einfügen von Daten in die Elemente in einer Liste alle durch Komma getrennten Werte in eckige Klammern [] ein, wie unten gezeigt.

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

Aktualisieren einer Liste

Im Folgenden finden Sie ein Beispiel zum Aktualisieren des Listendatentyps in einer aufgerufenen Tabelle data. Hier fügen wir der Liste eine weitere E-Mail hinzu.

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

Überprüfung

Wenn Sie die Tabelle mit der Anweisung SELECT überprüfen, erhalten Sie das folgende Ergebnis:

cqlsh:tutorialspoint> SELECT * FROM data;

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

(1 rows)

EINSTELLEN

Set ist ein Datentyp, der zum Speichern einer Gruppe von Elementen verwendet wird. Die Elemente eines Satzes werden in sortierter Reihenfolge zurückgegeben.

Erstellen einer Tabelle mit Set

Im folgenden Beispiel wird eine Beispieltabelle mit zwei Spalten erstellt: Name und Telefon. Zum Speichern mehrerer Telefonnummern verwenden wir set.

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

Einfügen von Daten in einen Satz

Geben Sie beim Einfügen von Daten in die Elemente einer Menge alle durch Komma getrennten Werte in geschweiften Klammern {} ein, wie unten gezeigt.

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

Ein Set aktualisieren

Der folgende Code zeigt, wie ein Satz in einer Tabelle mit dem Namen data2 aktualisiert wird. Hier fügen wir dem Set eine weitere Telefonnummer hinzu.

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

Überprüfung

Wenn Sie die Tabelle mit der Anweisung SELECT überprüfen, erhalten Sie das folgende Ergebnis:

cqlsh:tutorialspoint> SELECT * FROM data2;

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

(1 rows)

KARTE

Map ist ein Datentyp, der zum Speichern eines Schlüssel-Wert-Elementpaars verwendet wird.

Erstellen einer Tabelle mit Map

Das folgende Beispiel zeigt, wie eine Beispieltabelle mit zwei Spalten, Name und Adresse, erstellt wird. Zum Speichern mehrerer Adresswerte verwenden wir map.

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

Einfügen von Daten in eine Karte

Geben Sie beim Einfügen von Daten in die Elemente einer Karte alle ein key : value Paare durch Komma in geschweiften Klammern {} getrennt, wie unten gezeigt.

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

Ein Set aktualisieren

Der folgende Code zeigt, wie der Kartendatentyp in einer Tabelle mit dem Namen data3 aktualisiert wird. Hier ändern wir den Wert des Schlüsselbüros, dh wir ändern die Büroadresse einer Person namens Robin.

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

Überprüfung

Wenn Sie die Tabelle mit der Anweisung SELECT überprüfen, erhalten Sie das folgende Ergebnis:

cqlsh:tutorialspoint> select * from data3;

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

(1 rows)

CQL bietet die Möglichkeit, benutzerdefinierte Datentypen zu erstellen und zu verwenden. Sie können einen Datentyp erstellen, um mehrere Felder zu verarbeiten. In diesem Kapitel wird erläutert, wie Sie einen benutzerdefinierten Datentyp erstellen, ändern und löschen.

Erstellen eines benutzerdefinierten Datentyps

Der Befehl CREATE TYPEwird verwendet, um einen benutzerdefinierten Datentyp zu erstellen. Die Syntax lautet wie folgt:

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

Beispiel

Im Folgenden finden Sie ein Beispiel zum Erstellen eines benutzerdefinierten Datentyps. In diesem Beispiel erstellen wir einecard_details Datentyp mit den folgenden Details.

Feld	Feldname	Datentyp
Kreditkartennummer	num	int
Kreditkarten-Pin	Stift	int
Name auf der Kreditkarte	Name	Text
cvv	cvv	int
Kontaktdaten des Karteninhabers	Telefon	einstellen

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

Note - Der für den benutzerdefinierten Datentyp verwendete Name sollte nicht mit den reservierten Typnamen übereinstimmen.

Überprüfung

Verwenden Sie die DESCRIBE Befehl, um zu überprüfen, ob der erstellte Typ erstellt wurde oder nicht.

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

Ändern eines benutzerdefinierten Datentyps

ALTER TYPE- Befehl wird verwendet, um einen vorhandenen Datentyp zu ändern. Mit ALTER können Sie ein neues Feld hinzufügen oder ein vorhandenes Feld umbenennen.

Hinzufügen eines Feldes zu einem Typ

Verwenden Sie die folgende Syntax, um einem vorhandenen benutzerdefinierten Datentyp ein neues Feld hinzuzufügen.

ALTER TYPE typename
ADD field_name field_type;

Der folgende Code fügt dem Feld ein neues Feld hinzu Card_detailsDatentyp. Hier fügen wir ein neues Feld namens E-Mail hinzu.

cqlsh:tutorialspoint> ALTER TYPE card_details ADD email text;

Überprüfung

Verwenden Sie die DESCRIBE Befehl, um zu überprüfen, ob das neue Feld hinzugefügt wurde oder nicht.

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

Umbenennen eines Feldes in einem Typ

Verwenden Sie die folgende Syntax, um einen vorhandenen benutzerdefinierten Datentyp umzubenennen.

ALTER TYPE typename
RENAME existing_name TO new_name;

Der folgende Code ändert den Namen des Feldes in einem Typ. Hier benennen wir das Feld E-Mail in Mail um.

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

Überprüfung

Verwenden Sie die DESCRIBE Befehl, um zu überprüfen, ob sich der Typname geändert hat oder nicht.

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

Löschen eines benutzerdefinierten Datentyps

DROP TYPEist der Befehl zum Löschen eines benutzerdefinierten Datentyps. Im Folgenden finden Sie ein Beispiel zum Löschen eines benutzerdefinierten Datentyps.

Beispiel

Überprüfen Sie vor dem Löschen die Liste aller benutzerdefinierten Datentypen mit DESCRIBE_TYPES Befehl wie unten gezeigt.

cqlsh:tutorialspoint> DESCRIBE TYPES;
card_details card

Löschen Sie aus den beiden Typen den genannten Typ card Wie nachfolgend dargestellt.

cqlsh:tutorialspoint> drop type card;

Verwenden Sie die DESCRIBE Befehl, um zu überprüfen, ob der Datentyp gelöscht wurde oder nicht.

cqlsh:tutorialspoint> describe types;

card_details