Cassandra 简介
Apache Cassandra是一个高度可扩展的高性能分布式数据库，用于处理大量商用服务器上的大量数据，提供高可用性，无单点故障。这是一种NoSQL类型的数据库。 让我们先了解一下NoSQL数据库。
NoSQL 数据库
NoSQL数据库（有时称为“不是唯一的SQL”）是一种数据库，它提供一种机制来存储和检索数据，而不是关系数据库中使用的表格关系。这些数据库是无架构的，支持简单的复制，具有简单的API，最终一致，并且可以处理大量的数据。
NoSQL数据库的主要目的在于：
- 设计简单
- 水平缩放
- 更好地控制可用性
与关系数据库相比，NoSql数据库使用不同的数据结构。它使NoSQL中的一些操作更快。给定NoSQL数据库的适用性取决于它必须解决的问题。
NoSQL数据库与关系数据库
下表列出了区分从NoSQL的数据库关系数据库的各点。
| 关系数据库 | NoSQL数据库 |
|---|---|
| 支持强大的查询语言。 | 支持非常简单的查询语言。 |
| 它具有固定的模式。 | 无固定模式。 |
| 遵循ACID（原子性，一致性，隔离性和持久性）。 | 只有“最终一致”。 |
| 支持事务。 | 不支持事务。 |
除了Cassandra，我们有以下NoSQL数据库是相当受欢迎：
-
Apache的HBase的 - HBase是一个开放源代码，非关系型，分布式数据库，以Google的BigTable为模型，用Java编写。它作为Apache Hadoop项目的一部分开发，在HDFS之上运行，为Hadoop提供类似于BigTable的功能。
-
MongoDB的 - MongoDB是一个跨平台的面向文档的数据库系统，避免使用传统的基于表的关系数据库结构，使用动态模式的类似JSON的文档，使得在某些类型的应用程序中的数据集成更容易和更快。
什么是Apache Cassandra？
Apache Cassandra是一个开源，分布式和分散式/分布式存储系统（数据库），用于管理遍布世界各地的大量结构化数据。它提供高可用性的服务，没有单点故障。
下面列出了Apache Cassandra的一些值得注意的地方：
-
它是可扩展，容错和一致的。
-
它是一个面向列的数据库。
-
它的分布设计基于Amazon的Dynamo及其在Google的Bigtable上的数据模型。
-
创建在Facebook，它与关系数据库管理系统有很大的不同。
-
Cassandra实现了一个没有单点故障的Dynamo风格的复制模型，但增加了一个更强大的“列族”数据模型。
-
Cassandra被一些最大的公司使用，如Facebook，Twitter，Cisco，Rackspace，ebay，Netflix等。
Cassandra的特点
Cassandra因其卓越的技术特性而变得如此受欢迎。下面给出了Cassandra的一些特性：
-
弹性可扩展性 - Cassandra是高度可扩展的; 它允许添加更多的硬件以适应更多的客户和更多的数据根据要求。
-
始终基于架构 - Cassandra没有单点故障，它可以连续用于不能承担故障的关键业务应用程序。
-
快速线性性能 - Cassandra是线性可扩展性的，即它为你增加集群中的节点数量增加你的吞吐量。因此，保持一个快速的响应时间。
-
灵活的数据存储 - Cassandra适应所有可能的数据格式，包括：结构化，半结构化和非结构化。它可以根据您的需要动态地适应变化的数据结构。
-
便捷的数据分发 - Cassandra通过在多个数据中心之间复制数据，可以灵活地在需要时分发数据。
-
事务支持 - Cassandra支持属性，如原子性，一致性，隔离和持久性（ACID）。
-
快速写入 - Cassandra被设计为在廉价的商品硬件上运行。 它执行快速写入，并可以存储数百TB的数据，而不牺牲读取效率。
Cassandra的历史
- Cassandra在Facebook上开发了收件箱搜索。
- 它是由Facebook在2008年7月开放了源代码。
- Cassandra于2009年3月被纳入Apache孵化器。
- 它自2010年2月以来成为一个Apache顶级项目。
Cassandra 架构
Cassandra的设计目的是处理跨多个节点的大数据工作负载，而没有任何单点故障。Cassandra在其节点之间具有对等分布式系统，并且数据分布在集群中的所有节点之间。
-
集群中的所有节点都扮演相同的角色。 每个节点是独立的，并且同时互连到其他节点。
-
集群中的每个节点都可以接受读取和写入请求，无论数据实际位于集群中的何处。
-
当节点关闭时，可以从网络中的其他节点提供读/写请求。
Cassandra中的数据复制
在Cassandra中，集群中的一个或多个节点充当给定数据片段的副本。如果检测到一些节点以过期值响应，Cassandra将向客户端返回最近的值。返回最新的值后，Cassandra在后台执行读修复以更新失效值。
下图显示了Cassandra如何在集群中的节点之间使用数据复制，以确保没有单点故障的示意图。
注 - Cassandra在后台使用Gossip协议，允许节点相互通信并检测集群中的任何故障节点。
Cassandra的组件
Cassandra的关键组件如下：
-
节点 - 它是存储数据的地方。
-
数据中心 - 它是相关节点的集合。
-
集群 - 集群是包含一个或多个数据中心的组件。
-
提交日志 - 提交日志是Cassandra中的崩溃恢复机制。每个写操作都写入提交日志。
-
Mem-表 - mem-表是存储器驻留的数据结构。提交日志后，数据将被写入mem表。有时，对于单列族，将有多个mem表。
-
SSTable - 它是一个磁盘文件，当其内容达到阈值时，数据从mem表中刷新。
-
布隆过滤器 - 这些只是快速，非确定性的算法，用于测试元素是否是集合的成员。它是一种特殊的缓存。 每次查询后访问Bloom过滤器。
Cassandra 查询语言
用户可以使用Cassandra查询语言（CQL）通过其节点访问Cassandra。CQL将数据库（Keyspace）视为表的容器。 程序员使用cqlsh：提示以使用CQL或单独的应用程序语言驱动程序。
客户端针对其读写操作访问任何节点。该节点（协调器）在客户端和保存数据的节点之间播放代理。
写操作
节点的每个写入活动都由写在节点中的提交日志捕获。稍后数据将被捕获并存储在存储器表中。每当内存表满时，数据将写入SStable数据文件。所有写入都会在整个集群中自动分区和复制。Cassandra会定期整合SSTables，丢弃不必要的数据。
读操作
在读操作，Cassandra 从MEM-表得到的值，并检查过滤器绽放找到保存所需数据的相应的SSTable。
Cassandra 数据模型
Cassandra的数据模型与我们通常在RDBMS中看到的数据模型有很大的不同。本章介绍了Cassandra如何存储数据的概述。
集群（Cluster）
Cassandra数据库分布在几个一起操作的机器上。最外层容器被称为群集。对于故障处理，每个节点包含一个副本，如果发生故障，副本将负责。Cassandra按照环形格式将节点排列在集群中，并为它们分配数据。
键空间 （Keyspace）
键空间是Cassandra中数据的最外层容器。Cassandra中的一个键空间的基本属性是 -
-
复制因子 - 它是集群中将接收相同数据副本的计算机数。
-
副本放置策略 - 它只是把副本放在戒指中的策略。我们有简单策略（机架感知策略），旧网络拓扑策略（机架感知策略）和网络拓扑策略（数据中心共享策略）等策略。
-
列族 - 键空间是一个或多个列族的列表的容器。列族又是一个行集合的容器。每行包含有序列。列族表示数据的结构。每个键空间至少有一个，通常是许多列族。
创建键空间的语法如下 -
CREATE KEYSPACE Keyspace name
WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};
下图显示了键空间的示意图。
列族
列族是有序收集行的容器。每一行又是一个有序的列集合。下表列出了区分列系列和关系数据库表的要点。
| 关系表 | Cassandra列族 |
|---|---|
| 关系模型中的模式是固定的。 一旦为表定义了某些列，在插入数据时，在每一行中，所有列必须至少填充一个空值。 | 在Cassandra中，虽然定义了列族，但列不是。 您可以随时向任何列族自由添加任何列。 |
| 关系表只定义列，用户用值填充表。 | 在Cassandra中，表包含列，或者可以定义为超级列族。 |
Cassandra列族具有以下属性 -
-
keys_cached - 它表示每个SSTable保持缓存的位置数。
-
rows_cached - 它表示其整个内容将在内存中缓存的行数。
-
preload_row_cache -它指定是否要预先填充行缓存。
注 - 与不是固定列族的模式的关系表不同，Cassandra不强制单个行拥有所有列。
下图显示了Cassandra列族的示例。
列
列是Cassandra的基本数据结构，具有三个值，即键或列名称，值和时间戳。下面给出了列的结构。
超级列
超级列是一个特殊列，因此，它也是一个键值对。但是超级列存储了子列的地图。
通常列族被存储在磁盘上的单个文件中。因此，为了优化性能，重要的是保持您可能在同一列族中一起查询的列，并且超级列在此可以有所帮助。下面是超级列的结构。
Cassandra 和 RDBMS 的数据模型
下表列出了区分Cassandra的数据模型和RDBMS的数据模型的要点。
| RDBMS | Cassandra |
|---|---|
| RDBMS处理结构化数据。 | Cassandra处理非结构化数据。 |
| 它具有固定的模式。 | Cassandra具有灵活的架构。 |
| 在RDBMS中，表是一个数组的数组。 （ROW x COLUMN） | 在Cassandra中，表是“嵌套的键值对”的列表。 （ROW x COLUMN键x COLUMN值） |
| 数据库是包含与应用程序对应的数据的最外层容器。 | Keyspace是包含与应用程序对应的数据的最外层容器。 |
| 表是数据库的实体。 | 表或列族是键空间的实体。 |
| Row是RDBMS中的单个记录。 | Row是Cassandra中的一个复制单元。 |
| 列表示关系的属性。 | Column是Cassandra中的存储单元。 |
| RDBMS支持外键的概念，连接。 | 关系是使用集合表示。 |
Cassandra 安装
Cassandra可以使用cqlsh以及不同语言的驱动程序访问。本章介绍如何设置cqlsh和java环境以使用Cassandra。
预安装设置
在Linux环境中安装Cassandra之前，我们需要使用ssh（安全Shell）设置Linux。按照以下步骤设置Linux环境。
创建用户
在开始时，建议为Hadoop创建一个单独的用户，以便将Hadoop文件系统与Unix文件系统隔离。 按照以下步骤创建用户。
-
使用命令“su”打开根。
-
使用命令“useradd username”从root帐户创建用户。
-
现在您可以使用命令“su username”打开现有的用户帐户。
打开Linux终端并键入以下命令以创建用户。
$ su password: # useradd hadoop # passwd hadoop New passwd: Retype new passwd
SSH设置和密钥生成
需要SSH设置才能在集群上执行不同的操作，例如启动，停止和分布式守护程序shell操作。要对Hadoop的不同用户进行身份验证，需要为Hadoop用户提供公钥/私钥对，并与不同的用户共享。
以下命令用于使用SSH生成键值对：
- 将公共密钥表单id_rsa.pub复制到authorized_keys，
- 并提供所有者，
- 分别对authorized_keys文件的读写权限。
$ ssh-keygen -t rsa $ cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys $ chmod 0600 ~/.ssh/authorized_keys
- 验证SSH：
ssh localhost
安装Java
Java是Cassandra的主要先决条件。 首先，您应该使用以下命令验证系统中是否存在Java：
$ java -version
如果一切正常，它会给你以下输出。
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)
如果您的系统中没有Java，请按照以下步骤安装Java。
第1步
从以下链接下载java（JDK <latest version> - X64.tar.gz）：链接
然后jdk-7u71-linux-x64.tar.gz将下载到您的系统上。
第2步
通常你会在下载文件夹中找到下载的java文件。 使用以下命令验证它并解压缩jdk-7u71-linux-x64.gz文件。
$ 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
第3步
要使Java对所有用户可用，您必须将其移动到位置“/ usr / local /”。 打开root，然后键入以下命令。
$ su password: # mv jdk1.7.0_71 /usr/local/ # exit
第4步
要设置PATH和JAVA_HOME变量，请将以下命令添加到〜/ .bashrc文件。
export JAVA_HOME = /usr/local/jdk1.7.0_71 export PATH = $PATH:$JAVA_HOME/bin
现在，将所有更改应用到当前运行的系统。
$ source ~/.bashrc
第5步
使用以下命令配置java选项。
# alternatives --install /usr/bin/java java usr/local/java/bin/java 2 # alternatives --install /usr/bin/javac javac usr/local/java/bin/javac 2 # alternatives --install /usr/bin/jar jar usr/local/java/bin/jar 2 # alternatives --set java usr/local/java/bin/java # alternatives --set javac usr/local/java/bin/javac # alternatives --set jar usr/local/java/bin/jar
现在如上所述从终端使用java -version命令。
设置路径
在“/.bashrc”中设置Cassandra路径的路径，如下所示。
[hadoop@linux ~]$ gedit ~/.bashrc export CASSANDRA_HOME = ~/cassandra export PATH = $PATH:$CASSANDRA_HOME/bin
下载 Cassandra
Apache Cassandra可用的下载链接，Cassandra使用以下命令。
$ wget http://supergsego.com/apache/cassandra/2.1.2/apache-cassandra-2.1.2-bin.tar.gz
使用命令zxvf解压缩Cassandra，如下所示。
$ tar zxvf apache-cassandra-2.1.2-bin.tar.gz.
创建一个名为cassandra的新目录，并将下载的文件的内容移动到它，如下所示。
$ mkdir Cassandra $ mv apache-cassandra-2.1.2/* cassandra.
配置 Cassandra
打开cassandra.yaml：文件，它将在Cassandra的bin目录中。
$ gedit cassandra.yaml
注意：如果您从deb或rpm包安装了Cassandra，配置文件将位于Cassandra的/ etc / cassandra目录中。
以上命令打开cassandra.yaml文件。验证以下配置。 默认情况下，这些值将设置为指定的目录。
-
data_file_directories“/ var / lib / cassandra / data”
-
commitlog_directory “/var/lib/cassandra/commitlog”
-
saved_caches_directory “/var/lib/cassandra/saved_caches”
确保这些目录存在并且可以写入，如下所示。
创建目录
作为超级用户，创建两个目录/ var / lib / cassandra和/var./lib/cassandra，Cassandra将其数据写入其中。
[root@linux cassandra]# mkdir /var/lib/cassandra [root@linux cassandra]# mkdir /var/log/cassandra
授予文件夹权限
给新创建的文件夹授予读写权限，如下所示。
[root@linux /]# chmod 777 /var/lib/cassandra [root@linux /]# chmod 777 /var/log/cassandra
启动 Cassandra
要启动Cassandra，请打开终端窗口，导航到Cassandra主目录/ home，解压缩Cassandra，然后运行以下命令启动Cassandra服务器。
$ cd $CASSANDRA_HOME $./bin/cassandra -f
使用-f选项告诉Cassandra保留在前台，而不是作为后台进程运行。如果一切顺利，您可以看到Cassandra服务器启动。
编程环境
要以编程方式设置Cassandra，请下载以下jar文件：
- 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
将它们放在单独的文件夹中。例如，我们正在将这些jar下载到名为“Cassandra_jars”的文件夹。
在“.bashrc”文件中设置此文件夹的类路径，如下所示。
[hadoop@linux ~]$ gedit ~/.bashrc //Set the following class path in the .bashrc file. export CLASSPATH = $CLASSPATH:/home/hadoop/Cassandra_jars/*
Eclipse环境
打开Eclipse并创建一个名为Cassandra Examples的新项目。
右键单击项目，选择构建路径→配置构建路径，如下所示。
它将打开属性窗口。在库选项卡下，选择添加外部JAR。导航到您保存您的jar文件的目录。选择所有五个jar文件，然后单击确定，如下所示。
在参考库下，您可以看到添加了所有必需的jar，如下所示：
Maven依赖
下面给出了使用maven构建Cassandra项目的pom.xml。
<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>
Cassandra 参考API
本章涵盖Cassandra中的所有重要类。
集群（Cluster）
这个类是驱动程序的主要入口点。它属于com.datastax.driver.core包。
方法
| 序号 | 方法和描述 |
|---|---|
| 1 | Session connect() 它在当前集群上创建一个新会话并对其进行初始化。 |
| 2 | void close() 它用于关闭集群实例。 |
| 3 | static Cluster.Builder builder() 它用于创建一个新的Cluster.Builder实例。 |
Cluster.Builder
此类用于实例化Cluster.Builder类。
方法
| 序号 | 方法和描述 |
|---|---|
| 1 | Cluster.Builder addContactPoint(String address) 此方法向集群添加联系人。 |
| 2 | Cluster build() 此方法使用给定的接触点构建集群。 |
会话
此接口保存与Cassandra群集的连接。使用此接口，可以执行CQL查询。它属于com.datastax.driver.core包。
方法
| 序号 | 方法和描述 |
|---|---|
| 1 | void close() 此方法用于关闭当前会话实例。 |
| 2 | ResultSet execute(Statement statement) 此方法用于执行查询。它需要一个语句对象。 |
| 3 | ResultSet execute(String query) 此方法用于执行查询。它需要一个String对象形式的查询。 |
| 4 | PreparedStatement prepare(RegularStatement statement) 该方法准备提供的查询。查询将以Statement的形式提供。 |
| 5 | PreparedStatement prepare(String query) 该方法准备提供的查询。查询将以String的形式提供。 |
Cassandra Cqlsh
本章介绍Cassandra查询语言shell，并解释如何使用其命令。
默认情况下，Cassandra提供一个提示Cassandra查询语言shell（cqlsh），允许用户与它通信。使用此shell，您可以执行Cassandra查询语言（CQL）。
使用cqlsh，你可以
- 定义模式，
- 插入数据，
- 执行查询。
启动cqlsh
使用命令cqlsh启动cqlsh，如下所示。它提供Cassandra cqlsh提示作为输出。
[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 - 如上所述，此命令用于启动cqlsh提示符。此外，它还支持更多的选项。下表说明了cqlsh的所有选项及其用法。
| 选项 | 用法 |
|---|---|
| cqlsh --help | 显示有关cqlsh命令的选项的帮助主题。 |
| cqlsh --version | 提供您正在使用的cqlsh的版本。 |
| cqlsh --color | 指示shell使用彩色输出。 |
| cqlsh --debug | 显示更多的调试信息。 |
| cqlsh --execute cql_statement | 指示shell接受并执行CQL命令。 |
| cqlsh --file= “file name” | 如果使用此选项，Cassandra将在给定文件中执行命令并退出。 |
| cqlsh --no-color | 指示Cassandra不使用彩色输出。 |
| cqlsh -u “user name” | 使用此选项，您可以验证用户。默认用户名为：cassandra。 |
| cqlsh-p “pass word” | 使用此选项，您可以使用密码验证用户。默认密码为：cassandra。 |
Cqlsh命令
Cqlsh有几个命令，允许用户与它进行交互。命令如下所示。
记录的Shell命令
下面给出了Cqlsh记录的shell命令。这些是用于执行任务的命令，如显示帮助主题，退出cqlsh，描述等。
-
HELP -显示所有cqlsh命令的帮助主题。
-
CAPTURE -捕获命令的输出并将其添加到文件。
-
CONSISTENCY -显示当前一致性级别，或设置新的一致性级别。
-
COPY -将数据复制到Cassandra并从Cassandra复制数据。
-
DESCRIBE -描述Cassandra及其对象的当前集群。
-
EXPAND -纵向扩展查询的输出。
-
EXIT -使用此命令，可以终止cqlsh。
-
PAGING -启用或禁用查询分页。
-
SHOW -显示当前cqlsh会话的详细信息，如Cassandra版本，主机或数据类型假设。
-
SOURCE -执行包含CQL语句的文件。
-
TRACING -启用或禁用请求跟踪。
CQL数据定义命令
-
CREATE KEYSPACE -在Cassandra中创建KeySpace。
-
USE -连接到已创建的KeySpace。
-
ALTER KEYSPACE -更改KeySpace的属性。
-
DROP KEYSPACE -删除KeySpace。
-
CREATE TABLE -在KeySpace中创建表。
-
ALTER TABLE -修改表的列属性。
-
DROP TABLE -删除表。
-
TRUNCATE -从表中删除所有数据。
-
CREATE INDEX -在表的单个列上定义新索引。
-
DROP INDEX -删除命名索引。
CQL数据操作指令
-
INSERT -在表中添加行的列。
-
UPDATE -更新行的列。
-
DELETE -从表中删除数据。
-
BATCH -一次执行多个DML语句。
CQL字句
-
SELECT -此子句从表中读取数据
-
WHERE -where子句与select一起使用以读取特定数据。
-
ORDERBY -orderby子句与select一起使用，以特定顺序读取特定数据。
Cassandra Shell命令
除了CQL命令，Cassandra还提供了记录的shell命令。下面给出了Cassandra记录的shell命令。
Help
HELP命令显示所有cqlsh命令的摘要和简要描述。下面给出了help命令的用法。
cqlsh> help Documented shell commands: =========================== CAPTURE COPY DESCRIBE EXPAND PAGING SOURCE CONSISTENCY DESC EXIT HELP SHOW TRACING. CQL help topics: ================ ALTER CREATE_TABLE_OPTIONS SELECT ALTER_ADD CREATE_TABLE_TYPES SELECT_COLUMNFAMILY ALTER_ALTER CREATE_USER SELECT_EXPR ALTER_DROP DELETE SELECT_LIMIT ALTER_RENAME DELETE_COLUMNS SELECT_TABLE
Capture
此命令捕获命令的输出并将其添加到文件。例如，看看下面的代码，它将输出捕获到名为Outputfile的文件。
cqlsh> CAPTURE '/home/hadoop/CassandraProgs/Outputfile'
当我们在终端中键入任何命令时，输出将被给定的文件捕获。下面给出的是使用的命令和输出文件的快照。
cqlsh:tutorialspoint> select * from emp;
您可以使用以下命令关闭捕获。
cqlsh:tutorialspoint> capture off;
Consistency
此命令显示当前的一致性级别，或设置新的一致性级别。
cqlsh:tutorialspoint> CONSISTENCY Current consistency level is 1.
Copy
此命令将数据从Cassandra复制到文件并从中复制。下面给出一个将名为emp的表复制到文件myfile的示例。
cqlsh:tutorialspoint> COPY emp (emp_id, emp_city, emp_name, emp_phone,emp_sal) TO ‘myfile’; 4 rows exported in 0.034 seconds.
如果您打开并验证给定的文件，您可以找到复制的数据，如下所示。
Describe
此命令描述Cassandra及其对象的当前集群。此命令的变体说明如下。
Describe 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 -此命令列出集群中的所有键空间。下面给出了这个命令的用法。
cqlsh:tutorialspoint> describe keyspaces; system_traces system tp tutorialspoint
Describe tables -此命令列出了键空间中的所有表。下面给出了这个命令的用法。
cqlsh:tutorialspoint> describe tables; emp
Describe tables -此命令提供表的描述。下面给出了这个命令的用法。
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);
Describe tables
此命令用于描述用户定义的数据类型。下面给出了这个命令的用法。
cqlsh:tutorialspoint> describe type card_details; CREATE TYPE tutorialspoint.card_details ( num int, pin int, name text, cvv int, phone set<int>, mail text );
Describe Types
此命令列出所有用户定义的数据类型。下面给出了这个命令的用法。假设有两种用户定义的数据类型：card和card_details。
cqlsh:tutorialspoint> DESCRIBE TYPES; card_details card
Expand
此命令用于扩展输出。在使用此命令之前，您必须打开expand命令。下面给出了这个命令的用法。
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)
注意：您可以使用以下命令关闭展开选项。
cqlsh:tutorialspoint> expand off; Disabled Expanded output.
Exit
此命令用于终止cql shell。
Show
此命令显示当前cqlsh会话的详细信息，如Cassandra版本，主机或数据类型假设。下面给出了这个命令的用法。
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]
Source
使用此命令，可以在文件中执行命令。假设我们的输入文件如下：
然后可以执行包含命令的文件，如下所示。
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)
Cassandra 创建键空间
使用Cqlsh创建一个Keyspace
Cassandra中的键空间是一个定义节点上数据复制的命名空间。集群每个节点包含一个键空间。下面给出了使用语句CREATE KEYSPACE创建键空间的语法。
语句
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’;
CREATE KEYSPACE语句有两个属性：replication和durable_writes。
复制
复制选项用于指定副本位置策略和所需副本的数量。下表列出了所有副本位置策略。
| 策略名称 | 描述 |
|---|---|
| 简单的策略 | 为集群指定简单的复制因子。 |
| 网络拓扑策略 | 使用此选项，可以单独为每个数据中心设置复制因子。 |
| 旧网络拓扑策略 | 使用此选项，可以单独为每个数据中心设置复制因子。 |
使用此选项，您可以指示Cassandra是否对当前KeySpace的更新使用commitlog。此选项不是强制性的，默认情况下，它设置为true。
示例
下面给出了创建KeySpace的示例。
-
这里我们创建一个名为TutorialsPoint 的KeySpace。
-
我们使用第一个副本放置策略，即简单策略。
-
我们选择复制因子为1个副本。
cqlsh.> CREATE KEYSPACE tutorialspoint
WITH replication = {'class':'SimpleStrategy', 'replication_factor' : 3};
验证
您可以使用命令Describe验证是否创建表。如果对键空间使用此命令，它将显示如下所示创建的所有键空间。
cqlsh> DESCRIBE keyspaces; tutorialspoint system system_traces
在这里您可以观察新创建的KeySpace tutorialspoint。
Durable_writes
默认情况下，表的durable_writes属性设置为true，但可以将其设置为false。您不能将此属性设置为simplex策略。
示例
下面给出了示例持久写入属性的使用示例。
cqlsh> CREATE KEYSPACE test
... WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3 }
... AND DURABLE_WRITES = false;
验证
您可以通过查询系统键空间来验证test KeySpace的durable_writes属性是否设置为false。此查询提供了所有KeySpaces及其属性。
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)
在这里可以观察测试KeySpace的durable_writes属性设置为false。
使用Keyspace
您可以使用关键字USE使用创建的KeySpace。其语法如下：
Syntax:USE <identifier>
示例
在下面的示例中，我们使用KeySpace tutorialspoint。
cqlsh> USE tutorialspoint; cqlsh:tutorialspoint>
使用Java API创建一个Keyspace
您可以使用Session类的execute（）方法创建一个Keyspace。按照以下步骤使用Java API创建键空间。
第1步：创建一个集群对象
首先，创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以在单行代码中构建一个集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果已经有一个键空间，可以通过将字符串格式的键空间名称传递给这个方法来将其设置为现有键空间，如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在这个例子中，我们创建一个名为tp的KeySpace。我们使用第一个副本放置策略，即简单策略，我们选择复制因子为1个副本。
您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
String query = "CREATE KEYSPACE tp WITH replication "
+ "= {'class':'SimpleStrategy', 'replication_factor':1}; ";
session.execute(query);
第四步：使用KeySpace
您可以使用execute（）方法使用创建的KeySpace，如下所示。
execute(“ USE tp ” );
下面给出了使用Java API在Cassandra中创建和使用键空间的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Create_KeySpace.java $java Create_KeySpace
在正常条件下，它将产生以下输出：
Keyspace created
Cassandra 修改键空间
使用Cqlsh修改Keyspace
ALTER KEYSPACE可用于更改属性，例如，一个KeySpace的replicas和durable_writes的数量。下面给出了此命令的语法。
语句
ALTER KEYSPACE <identifier> WITH <properties>
即：
ALTER KEYSPACE “KeySpace Name”
WITH replication = {'class': ‘Strategy name’, 'replication_factor' : ‘No.Of replicas’};
ALTER KEYSPACE的属性与CREATE KEYSPACE相同。它有两个属性：replication和durable_writes。
Durable_writes
使用此选项，您可以指示Cassandra是否对当前KeySpace的更新使用commitlog。此选项不是强制性的，默认情况下，它设置为true。
示例
下面给出一个修改KeySpace的例子。
-
这里我们改变一个名为TutorialsPoint的KeySpace。
-
我们将复制因子从1更改为3。
cqlsh.> ALTER KEYSPACE tutorialspoint
WITH replication = {'class':'NetworkTopologyStrategy', 'replication_factor' : 3};
更改 Durable_writes
您还可以修改KeySpace的durable_writes属性。下面给出测试KeySpace的durable_writes属性。
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;
再次，如果您验证KeySpaces的属性，它将产生以下输出。
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)
使用Java API修改键空间
您可以使用Session类的execute（）方法来更改键空间。按照以下步骤使用Java API更改键空间
第1步：创建一个集群对象
首先，创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Clusterclass的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果已经有一个键空间，可以通过将字符串格式的键空间名称传递给这个方法来将其设置为现有键空间，如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在这个例子中，
-
我们正在改变一个名为tp的键空间。我们正在将复制选项从简单策略更改为网络拓扑策略。
-
我们正在将durable_writes更改为false
您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
//Query
String query = "ALTER KEYSPACE tp WITH replication " + "= {'class':'NetworkTopologyStrategy', 'datacenter1':3}" +" AND DURABLE_WRITES = false;";
session.execute(query);
下面给出了使用Java API在Cassandra中创建和使用键空间的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Alter_KeySpace.java $java Alter_KeySpace
在正常条件下，它产生以下输出：
Keyspace Altered
Cassandra 删除键空间
使用Cqlsh删除键空间
您可以使用命令DROP KEYSPACE删除KeySpace。下面给出了删除KeySpace的语法。
语句
DROP KEYSPACE <identifier>
即：
DROP KEYSPACE “KeySpace name”
示例
以下代码删除了keyspace tutorialspoint.
cqlsh> DROP KEYSPACE tutorialspoint;
验证
使用命令 Describe 验证键空间，并检查是否删除表，如下所示。
cqlsh> DESCRIBE keyspaces; system system_traces
由于我们已经删除了keyspace tutorialspoint，你不会在keyspace列表中找到它。
使用Java API删除键空间
您可以使用Session类的execute（）方法创建一个键空间。按照以下步骤使用Java API删除键空间。
第一步：创建群集对象
首先，创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果已经有一个键空间，可以通过将字符串格式的键空间名称传递给这个方法来将其设置为现有键空间，如下所示。
Session session = cluster.connect(“ Your keyspace name”);
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在下面的示例中，我们将删除名为tp的键空间。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
String query = "DROP KEYSPACE tp; "; session.execute(query);
下面给出了使用Java API在Cassandra中创建和使用键空间的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Delete_KeySpace.java $java Delete_KeySpace
在正常条件下，它应该产生以下输出：
Keyspace deleted
Cassandra 创建表
使用Cqlsh创建表
您可以使用命令CREATE TABLE创建表。下面给出了创建表的语法。
语句
CREATE (TABLE | COLUMNFAMILY) <tablename>
('<column-definition>' , '<column-definition>')
(WITH <option> AND <option>)
定义列
您可以定义一个列，如下所示。
column name1 data type, column name2 data type, example: age int, name text
主键
主键是用于唯一标识行的列。因此，在创建表时，必须定义主键。主键由表的一个或多个列组成。您可以定义表的主键，如下所示。
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) )
示例
下面给出一个使用cqlsh在Cassandra中创建表的示例。我们到了：
-
使用keyspace tutorialspoint
-
创建名为emp的表
它将有详细信息，如员工姓名，id，城市，工资和电话号码。Employee id是主键。
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 );
验证
select语句将为您提供模式。使用select语句验证表，如下所示。
cqlsh:tutorialspoint> select * from emp; emp_id | emp_city | emp_name | emp_phone | emp_sal --------+----------+----------+-----------+--------- (0 rows)
在这里，您可以观察使用给定列创建的表。由于我们已经删除了keyspace的教程节点，你不会在keyspace列表中找到它。
使用Java API创建表
您可以使用Session类的execute（）方法创建表。按照以下给出的步骤使用Java API创建表。
第1步：创建群集对象
首先，创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果已经有一个键空间，可以通过将字符串格式的键空间名称传递给这个方法来将其设置为现有键空间，如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
这里我们使用名为tp的键空间。因此，创建会话对象如下所示。
Session session = cluster.connect(“ tp” );
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在下面的示例中，我们将创建一个名为emp的表。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
//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);
下面给出了使用Java API在Cassandra中创建和使用键空间的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Create_Table.java $java Create_Table
在正常条件下，它应该产生以下输出：
Table created
Cassandra 创建表
使用Cqlsh创建表
您可以使用命令CREATE TABLE创建表。下面给出了创建表的语法。
语句
CREATE (TABLE | COLUMNFAMILY) <tablename>
('<column-definition>' , '<column-definition>')
(WITH <option> AND <option>)
定义列
您可以定义一个列，如下所示。
column name1 data type, column name2 data type, example: age int, name text
主键
主键是用于唯一标识行的列。因此，在创建表时，必须定义主键。主键由表的一个或多个列组成。您可以定义表的主键，如下所示。
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) )
示例
下面给出一个使用cqlsh在Cassandra中创建表的示例。我们到了：
-
使用keyspace tutorialspoint
-
创建名为emp的表
它将有详细信息，如员工姓名，id，城市，工资和电话号码。Employee id是主键。
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 );
验证
select语句将为您提供模式。使用select语句验证表，如下所示。
cqlsh:tutorialspoint> select * from emp; emp_id | emp_city | emp_name | emp_phone | emp_sal --------+----------+----------+-----------+--------- (0 rows)
在这里，您可以观察使用给定列创建的表。由于我们已经删除了keyspace的教程节点，你不会在keyspace列表中找到它。
使用Java API创建表
您可以使用Session类的execute（）方法创建表。按照以下给出的步骤使用Java API创建表。
第1步：创建群集对象
首先，创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果已经有一个键空间，可以通过将字符串格式的键空间名称传递给这个方法来将其设置为现有键空间，如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
这里我们使用名为tp的键空间。因此，创建会话对象如下所示。
Session session = cluster.connect(“ tp” );
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在下面的示例中，我们将创建一个名为emp的表。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
//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);
下面给出了使用Java API在Cassandra中创建和使用键空间的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Create_Table.java $java Create_Table
在正常条件下，它应该产生以下输出：
Table created
Cassandra 修改表
改变使用Cqlsh表
您可以使用命令ALTER TABLE更改表。下面给出了修改表的语法。
句法
ALTER (TABLE | COLUMNFAMILY) <tablename> <instruction>
使用ALTER命令，可以执行以下操作：
-
添加列
-
删除列
添加列
使用ALTER命令，可以向表中添加列。在添加列时，必须注意，列名称不会与现有列名称冲突，并且表未使用紧凑存储选项定义。下面给出了向表中添加列的语法。
ALTER TABLE table name ADD new column datatype;
示例
下面给出了向现有表中添加列的示例。这里我们在名为emp的表中添加一个名为emp_email的文本数据类型的列。
cqlsh:tutorialspoint> ALTER TABLE emp ... ADD emp_email text;
验证
使用SELECT语句验证列是否已添加。在这里可以观察新添加的列emp_email。
cqlsh:tutorialspoint> select * from emp; emp_id | emp_city | emp_email | emp_name | emp_phone | emp_sal --------+----------+-----------+----------+-----------+---------
删除列
使用ALTER命令，可以从表中删除列。在从表中删除列之前，请检查该表是否未使用紧凑存储选项进行定义。下面给出了使用ALTER命令从表中删除列的语法。
ALTER table name DROP column name;
示例
下面给出了从表中删除列的示例。这里我们删除名为emp_email的列。
cqlsh:tutorialspoint> ALTER TABLE emp DROP emp_email;
验证
使用select语句验证列是否已删除，如下所示。
cqlsh:tutorialspoint> select * from emp; emp_id | emp_city | emp_name | emp_phone | emp_sal --------+----------+----------+-----------+--------- (0 rows)
由于emp_email列已删除，因此您无法再找到它。
使用Java API更改表
您可以使用Session类的execute（）方法创建表。按照以下步骤使用Java API更改表。
第1步：创建集群对象
首先，创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，您可以通过将KeySpace名称以字符串格式传递到此方法来将其设置为现有键空间，如下所示。
Session session = cluster.connect(“ Your keyspace name ” ); Session session = cluster.connect(“ tp” );
这里我们使用KeySpace命名为tp。因此，创建会话对象如下所示。
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在以下示例中，我们向名为emp的表中添加列。为此，您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
//Query String query1 = "ALTER TABLE emp ADD emp_email text"; session.execute(query);
下面给出了向现有表中添加列的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Add_Column.java $java Add_Column
在正常条件下，它应该产生以下输出：
Column added
删除列
面给出了从现有表中删除列的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Delete_Column.java $java Delete_Column
在正常条件下，它应该产生以下输出：
Column deleted
Cassandra 删除表
使用Cqlsh删除表
您可以使用命令Drop Table删除表。其语法如下：
语法
DROP TABLE <tablename>
示例
以下代码从KeySpace删除现有表。
cqlsh:tutorialspoint> DROP TABLE emp;
验证
用Describe命令验证表是否已删除。由于emp表已删除，您不会在列族列表中找到它。
cqlsh:tutorialspoint> DESCRIBE COLUMNFAMILIES; employee
使用Java API删除表
您可以使用Session类的execute（）方法删除表。按照以下步骤使用Java API删除表。
第1步：创建集群对象
首先，创建一个Cluster.builder类的实例com.datastax.driver.core包，如下所示：
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，您可以通过将KeySpace名称以字符串格式传递到此方法来将其设置为现有键空间，如下所示。
Session session = cluster.connect(“Your keyspace name”);
这里我们使用名为tp的键空间。因此，创建会话对象如下所示。
Session session = cluster.connect(“tp”);
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在下面的示例中，我们将删除名为emp的表。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
// Query String query = "DROP TABLE emp1;”; session.execute(query);
下面给出了使用Java API在Cassandra中删除表的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Drop_Table.java $java Drop_Table
在正常条件下，它应该产生以下输出：
Table dropped
Cassandra 截断表
使用Cqlsh截断表
您可以使用TRUNCATE命令截断表。截断表时，表的所有行都将永久删除。下面给出了此命令的语法。
语法
TRUNCATE <tablename>
示例
让我们假设有一个名为student的表有以下数据。
| s_id | s_name | s_branch | s_aggregate |
|---|---|---|---|
| 1 | ram | IT | 70 |
| 2 | rahman | EEE | 75 |
| 3 | robbin | Mech | 72 |
当您执行select语句以获取表student时，它将给您以下输出。
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)
现在使用TRUNCATE命令截断表。
cqlsh:tp> TRUNCATE student;
验证
通过执行select语句验证表是否被截断。下面给出截断后学生表上的select语句的输出。
cqlsh:tp> select * from student; s_id | s_aggregate | s_branch | s_name ------+-------------+----------+-------- (0 rows)
使用Java API截断表
您可以使用Session类的execute（）方法截断表。按照以下步骤截断表。
第1步：创建集群对象
首先，创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，那么您可以通过将KeySpace名称以字符串格式设置为现有键空间，此方法如下所示。
Session session = cluster.connect(“ Your keyspace name ” ); Session session = cluster.connect(“ tp” );
这里我们使用名为tp的键空间。因此，创建会话对象如下所示。
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在下面的示例中，我们截断了一个名为emp的表。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
//Query String query = "TRUNCATE emp;;”; session.execute(query);
下面给出了使用Java API截断Cassandra中的表的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Truncate_Table.java $java Truncate_Table
在正常条件下，它应该产生以下输出：
Table truncated
Cassandra 创建索引
使用Cqlsh创建索引
您可以使用命令CREATE INDEX在Cassandra中创建索引。其语法如下：
CREATE INDEX <identifier> ON <tablename>
下面给出一个创建列的索引的例子。这里，我们在名为emp的表中为列“emp_name”创建索引。
cqlsh:tutorialspoint> CREATE INDEX name ON emp1 (emp_name);
使用Java API创建索引
您可以使用Session类的execute（）方法创建表的列的索引。按照下面给出的步骤为表中的列创建索引。
第一步：创建集群对象
首先，创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，那么您可以通过将KeySpace名称以字符串格式设置为现有键空间，此方法如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
这里我们使用KeySpace称为tp。因此，创建会话对象如下所示。
Session session = cluster.connect(“ tp” );
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在以下示例中，我们在名为emp的表中为名为emp_name的列创建索引。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
//Query String query = "CREATE INDEX name ON emp1 (emp_name);"; session.execute(query);
下面给出了使用Java API在Cassandra中的表中创建列的索引的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Create_Index.java $java Create_Index
在正常条件下，它应该产生以下输出：
Index created
Cassandra 删除索引
使用Cqlsh删除索引
您可以使用命令DROP INDEX删除索引。其语法如下：
DROP INDEX <identifier>
下面给出了删除表中列的索引的示例。这里我们删除表emp中的列名的索引。
cqlsh:tp> drop index name;
使用Java API删除索引
您可以使用Session类的execute（）方法删除表的索引。按照以下步骤从表中删除索引。
第1步：创建集群对象
创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，那么您可以通过将KeySpace名称以字符串格式设置为现有键空间，此方法如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
这里我们使用KeySpace命名为tp。因此，创建会话对象如下所示。
Session session = cluster.connect(“ tp” );
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在下面的示例中，我们删除了emp表的索引“name”。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
//Query String query = "DROP INDEX user_name;"; session.execute(query);
下面给出了使用Java API在Cassandra中删除索引的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Drop_index.java $java Drop_index
在正常条件下，它应该产生以下输出：
Index dropped
Cassandra 批处理
使用Cqlsh执行批处理语句
使用BATCH，您可以同时执行多个修改语句（插入，更新，删除）。其语法如下：
BEGIN BATCH <insert-stmt>/ <update-stmt>/ <delete-stmt> APPLY BATCH
示例
假设Cassandra中有一个名为emp的表，具有以下数据：
| 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 |
在这个例子中，我们将执行以下操作：
- 插入包含以下详细信息的新行（4，rajeev，pune，9848022331，30000）。
- 将行号为3的员工的工资更新为50000。
- 删除行ID为2的员工的城市。
要一次性执行上述操作，请使用以下BATCH命令：
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;
验证
更改后，使用SELECT语句验证表。它应该产生以下输出：
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)
这里可以观察具有修改数据的表。
使用Java API的批处理语句
可以使用Session类的execute（）方法以编程方式在表中编写批处理语句。按照下面给出的步骤在Java API的帮助下使用批处理语句执行多个语句。
第1步：创建集群对象
创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。使用以下代码创建集群对象：
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，那么您可以通过将KeySpace名称以字符串格式设置为现有键空间，此方法如下所示。
Session session = cluster.connect(“ Your keyspace name ”);
这里我们使用KeySpace命名为tp。因此，创建会话对象如下所示。
Session session = cluster.connect(“tp”);
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在这个例子中，我们将执行以下操作：
- 插入包含以下详细信息的新行（4，rajeev，pune，9848022331，30000）。
- 将行号为3的员工的工资更新为50000。
- 删除行ID为2的员工所在的城市。
您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
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;”;
下面给出的是使用Java API在Cassandra中的表上同时执行多个语句的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下所示。
$javac Batch.java $java Batch
在正常条件下，它应该产生以下输出：
Changes done
Cassandra 批处理
使用Cqlsh执行批处理语句
使用BATCH，您可以同时执行多个修改语句（插入，更新，删除）。其语法如下：
BEGIN BATCH <insert-stmt>/ <update-stmt>/ <delete-stmt> APPLY BATCH
示例
假设Cassandra中有一个名为emp的表，具有以下数据：
| 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 |
在这个例子中，我们将执行以下操作：
- 插入包含以下详细信息的新行（4，rajeev，pune，9848022331，30000）。
- 将行号为3的员工的工资更新为50000。
- 删除行ID为2的员工的城市。
要一次性执行上述操作，请使用以下BATCH命令：
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;
验证
更改后，使用SELECT语句验证表。它应该产生以下输出：
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)
这里可以观察具有修改数据的表。
使用Java API的批处理语句
可以使用Session类的execute（）方法以编程方式在表中编写批处理语句。按照下面给出的步骤在Java API的帮助下使用批处理语句执行多个语句。
第1步：创建集群对象
创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。使用以下代码创建集群对象：
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，那么您可以通过将KeySpace名称以字符串格式设置为现有键空间，此方法如下所示。
Session session = cluster.connect(“ Your keyspace name ”);
这里我们使用KeySpace命名为tp。因此，创建会话对象如下所示。
Session session = cluster.connect(“tp”);
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在这个例子中，我们将执行以下操作：
- 插入包含以下详细信息的新行（4，rajeev，pune，9848022331，30000）。
- 将行号为3的员工的工资更新为50000。
- 删除行ID为2的员工所在的城市。
您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
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;”;
下面给出的是使用Java API在Cassandra中的表上同时执行多个语句的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下所示。
$javac Batch.java $java Batch
在正常条件下，它应该产生以下输出：
Changes done
Cassandra 创建数据
使用Cqlsh创建数据
可以使用命令INSERT将数据插入到表中行的列中。下面给出了在表中创建数据的语法。
INSERT INTO <tablename> (<column1 name>, <column2 name>....) VALUES (<value1>, <value2>....) USING <option>
示例
让我们假设有一个名为emp的表（emp_id，emp_name，emp_city，emp_phone，emp_sal），并且必须将以下数据插入emp表。
| 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 |
使用下面给出的命令用所需的数据填充表。
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);
验证
插入数据后，使用SELECT语句验证数据是否已插入。如果使用SELECT语句验证emp表，它将给您以下输出。
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)
在这里你可以观察表中填充了我们插入的数据。
使用Java API创建数据
您可以使用Session类的execute（）方法在表中创建数据。按照以下步骤使用java API在表中创建数据。
第1步：创建集群对象
创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint("127.0.0.1");
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。以下代码显示如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，那么您可以通过将KeySpace名称以字符串格式设置为现有键空间，此方法如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
这里我们使用KeySpace称为tp。因此，创建会话对象如下所示。
Session session = cluster.connect(“ tp” );
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在下面的示例中，我们在emp表中插入数据。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
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);
下面给出了使用Java API将数据插入到Cassandra表中的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Create_Data.java $java Create_Data
在正常条件下，它应该产生以下输出：
Data created
Cassandra 更新数据
使用Cqlsh更新数据
UPDATE是用于更新表中的数据的命令。在更新表中的数据时使用以下关键字：
-
Where - 此子句用于选择要更新的行。
-
Set - 使用此关键字设置值。
-
Must - 包括组成主键的所有列。
在更新行时，如果给定行不可用，则UPDATE创建一个新行。下面给出了UPDATE命令的语法：
UPDATE <tablename> SET <column name> = <new value> <column name> = <value>.... WHERE <condition>
示例
假设有一个名为emp的表。此表存储某公司员工的详细信息，其具有以下详细信息：
| 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 |
现在让我们将robin的emp_city更新到Delhi，将他的工资更新为50000.以下是执行所需更新的查询。
cqlsh:tutorialspoint> UPDATE emp SET emp_city='Delhi',emp_sal=50000 WHERE emp_id=2;
验证
使用SELECT语句来验证数据是否已更新。如果使用SELECT语句验证emp表，它将产生以下输出。
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)
这里可以观察到表数据已更新。
使用Java API更新数据
您可以使用Session类的execute（）方法更新表中的数据。按照以下步骤使用Java API更新表中的数据。
第1步：创建集群对象
创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object
Cluster.Builder builder2 = build.addContactPoint("127.0.0.1");
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。使用以下代码创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，那么您可以通过将KeySpace名称以字符串格式设置为现有键空间，此方法如下所示。
Session session = cluster.connect(“ Your keyspace name”);
这里我们使用KeySpace命名为tp。因此，创建会话对象如下所示。
Session session = cluster.connect(“tp”);
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在下面的示例中，我们更新emp表。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示：
String query = “ UPDATE emp SET emp_city='Delhi',emp_sal=50000 WHERE emp_id = 2;” ;
下面给出了使用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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Update_Data.java $java Update_Data
在正常条件下，它应该产生以下输出：
Data updated
Cassandra 读取数据
使用选择子句读取数据
SELECT子句用于从Cassandra中的表读取数据。使用此子句，您可以读取整个表，单个列或特定单元格。下面给出了SELECT子句的语法。
SELECT FROM <tablename>
示例
假设在名为emp的键空间中有一个具有以下详细信息的表：
| 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 |
以下示例显示如何使用SELECT子句读取整个表。这里我们读一个表emp。
cqlsh:tutorialspoint> select * from emp;
emp_id | emp_city | emp_name | emp_phone | emp_sal
--------+-----------+----------+------------+---------
1 | Hyderabad | ram | 9848022338 | 50000
2 | null | robin | 9848022339 | 50000
3 | Chennai | rahman | 9848022330 | 50000
4 | Pune | rajeev | 9848022331 | 30000
(4 rows)
读取必需的列
以下示例显示如何读取表中的特定列。
cqlsh:tutorialspoint> SELECT emp_name, emp_sal from emp;
emp_name | emp_sal
----------+---------
ram | 50000
robin | 50000
rajeev | 30000
rahman | 50000
(4 rows)
Where子句
使用WHERE子句，可以对必需的列设置约束。其语法如下：
SELECT FROM <table name> WHERE <condition>;
注意：WHERE子句只能用于作为主键的一部分或在其上具有辅助索引的列。
在以下示例中，我们正在读取薪水为50000的员工的详细信息。首先，将辅助索引设置为列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
使用Java API读取数据
您可以使用Session类的execute（）方法从表中读取数据。按照下面给出的步骤在Java API的帮助下使用批处理语句执行多个语句。
第1步：创建集群对象
创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。使用以下代码创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并初始化它。如果您已经有一个键空间，那么您可以通过将KeySpace名称以字符串格式设置为现有键空间，此方法如下所示。
Session session = cluster.connect(“Your keyspace name”);
这里我们使用KeySpace称为tp。因此，创建会话对象如下所示。
Session session = cluster.connect(“tp”);
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在这个例子中，我们从emp表中检索数据。将查询存储在字符串中，并将其传递给会话类的execute（）方法，如下所示。
String query = ”SELECT 8 FROM emp”; session.execute(query);
使用Session类的execute（）方法执行查询。
第4步：获取ResultSet对象
select查询将以ResultSet对象的形式返回结果，因此将结果存储在RESULTSET类的对象中，如下所示。
ResultSet result = session.execute( );
下面给出的是从表中读取数据的完整程序。
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());
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Read_Data.java $java Read_Data
在正常条件下，它应该产生以下输出：
[Row[1, Hyderabad, ram, 9848022338, 50000], Row[2, Delhi, robin, 9848022339, 50000], Row[4, Pune, rajeev, 9848022331, 30000], Row[3, Chennai, rahman, 9848022330, 50000]]
Cassandra 删除数据
使用Cqlsh删除数据
您可以使用命令DELETE从表中删除数据。其语法如下：
DELETE FROM <identifier> WHERE <condition>;
示例
让我们假设Cassandra中有一个名为emp的具有以下数据的表：
| 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 |
以下语句删除最后一行的emp_sal列：
cqlsh:tutorialspoint> DELETE emp_sal FROM emp WHERE emp_id=3;
验证
使用SELECT语句验证数据是否已删除。如果使用SELECT验证emp表，它将产生以下输出：
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)
由于我们删除了Rahman的薪资，你将看到一个空值代替薪资。
删除整行
以下命令从表中删除整个行。
cqlsh:tutorialspoint> DELETE FROM emp WHERE emp_id=3;
验证
使用SELECT语句验证数据是否已删除。如果使用SELECT验证emp表，它将产生以下输出：
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)
由于我们删除了最后一行，因此表中只剩下两行。
使用Java API删除数据
您可以使用Session类的execute（）方法删除表中的数据。按照以下步骤使用java API从表中删除数据。
第1步：创建集群对象
创建一个名为com.datastax.driver.core的Cluster.builder类的实例，如下所示。
//Creating Cluster.Builder object Cluster.Builder builder1 = Cluster.builder();
使用Cluster.Builder对象的addContactPoint（）方法添加联系点（节点的IP地址）。此方法返回Cluster.Builder。
//Adding contact point to the Cluster.Builder object Cluster.Builder builder2 = build.addContactPoint( "127.0.0.1" );
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。使用以下代码创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用单行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
第2步：创建会话对象
使用Cluster类的connect（）方法创建一个Session对象的实例，如下所示。
Session session = cluster.connect();
使用新的构建器对象，创建一个集群对象。为此，在Cluster.Builder类中有一个名为build（）的方法。使用以下代码创建集群对象。
Session session = cluster.connect(“ Your keyspace name ”);
这里我们使用KeySpace称为tp。因此，创建会话对象如下所示。
Session session = cluster.connect(“tp”);
第3步：执行查询
您可以使用Session类的execute（）方法执行CQL查询。将查询以字符串格式或Statement类对象传递给execute（）方法。无论您以字符串格式传递给此方法将在cqlsh上执行。
在下面的示例中，我们从名为emp的表中删除数据。您必须将查询存储在字符串变量中，并将其传递给execute（）方法，如下所示。
String query1 = ”DELETE FROM emp WHERE emp_id=3; ”; session.execute(query);
下面给出了使用Java API从Cassandra中的表中删除数据的完整程序。
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");
}
}
使用类名称和.java保存上述程序，浏览到保存位置。编译并执行程序如下图所示。
$javac Delete_Data.java $java Delete_Data
在正常条件下，它应该产生以下输出：
Data deleted
Cassandra CQL数据类型
CQL提供了一组丰富的内置数据类型，包括集合类型。除了这些数据类型，用户还可以创建自己的自定义数据类型。下表提供了CQL中可用的内置数据类型的列表。
| 数据类型 | 常量 | 描述 |
|---|---|---|
| ascii | strings | 表示ASCII字符串 |
| bigint | bigint | 表示64位有符号长 |
| blob | blobs | 表示任意字节 |
| Boolean | booleans | 表示true或false |
| counter | integers | 表示计数器列 |
| decimal | integers, floats | 表示变量精度十进制 |
| double | integers | 表示64位IEEE-754浮点 |
| float | integers, floats | 表示32位IEEE-754浮点 |
| inet | strings | 表示一个IP地址，IPv4或IPv6 |
| int | integers | 表示32位有符号整数 |
| text | strings | 表示UTF8编码的字符串 |
| timestamp | integers, strings | 表示时间戳 |
| timeuuid | uuids | 表示类型1 UUID |
| uuid | uuids | 表示类型1或类型4 |
| UUID | ||
| varchar | strings | 表示uTF8编码的字符串 |
| varint | integers | 表示任意精度整数 |
集合类型
Cassandra查询语言还提供了一个集合数据类型。下表提供了CQL中可用的集合的列表。
| 集合 | 描述 |
|---|---|
| list | 列表是一个或多个有序元素的集合。 |
| map | 地图是键值对的集合。 |
| set | 集合是一个或多个元素的集合。 |
用户定义的数据类型：
Cqlsh为用户提供了创建自己的数据类型的工具。下面给出了处理用户定义的数据类型时使用的命令。
-
CREATE TYPE -创建用户定义的数据类型。
-
ALTER TYPE -修改用户定义的数据类型。
-
DROP TYPE -删除用户定义的数据类型。
-
DESCRIBE TYPE -描述用户定义的数据类型。
-
DESCRIBE TYPES -描述用户定义的数据类型。
Cassandra CQL集合
CQL提供了使用Collection数据类型的功能。使用这些集合类型，您可以在单个变量中存储多个值。本章介绍如何在Cassandra中使用Collections。
List
List用于以下的情况下
- 将保持元素的顺序，并且
- 值将被多次存储。
您可以使用列表中元素的索引来获取列表数据类型的值。
使用List创建表
下面给出了一个创建一个包含两个列（名称和电子邮件）的样本表的示例。要存储多个电子邮件，我们使用列表。
cqlsh:tutorialspoint> CREATE TABLE data(name text PRIMARY KEY, email list<text>);
将数据插入列表
在将数据插入列表中的元素时，在如下所示的方括号[]中输入以逗号分隔的所有值。
cqlsh:tutorialspoint> INSERT INTO data(name, email) VALUES ('ramu',
['abc@gmail.com','cba@yahoo.com'])
更新列表
下面给出了一个在名为data的表中更新列表数据类型的示例。在这里，我们正在向列表中添加另一封电子邮件。
cqlsh:tutorialspoint> UPDATE data ... SET email = email +['xyz@tutorialspoint.com'] ... where name = 'ramu';
验证
如果使用SELECT语句验证表，您将得到以下结果：
cqlsh:tutorialspoint> SELECT * FROM data; name | email ------+-------------------------------------------------------------- ramu | ['abc@gmail.com', 'cba@yahoo.com', 'xyz@tutorialspoint.com'] (1 rows)
Set
Set是用于存储一组元素的数据类型。集合的元素将按排序顺序返回。
使用Set创建表
以下示例创建一个包含两个列（名称和电话）的样本表。对于存储多个电话号码，我们使用集合。
cqlsh:tutorialspoint> CREATE TABLE data2 (name text PRIMARY KEY, phone set<varint>);
将数据插入集合
在将数据插入集合中的元素时，请在花括号{}中输入逗号分隔的所有值，如下所示。
cqlsh:tutorialspoint> INSERT INTO data2(name, phone)VALUES ('rahman', {9848022338,9848022339});
更新集合
以下代码显示如何更新名为data2的表中的集合。在这里，我们正在添加另一个电话号码。
cqlsh:tutorialspoint> UPDATE data2
... SET phone = phone + {9848022330}
... where name = 'rahman';
验证
如果使用SELECT语句验证表，您将得到以下结果：
cqlsh:tutorialspoint> SELECT * FROM data2;
name | phone
--------+--------------------------------------
rahman | {9848022330, 9848022338, 9848022339}
(1 rows)
Map
地图是用于存储元素的键值对的数据类型。
使用Map创建表
以下示例显示如何创建具有两个列（名称和地址）的样本表。为了存储多个地址值，我们使用map。
cqlsh:tutorialspoint> CREATE TABLE data3 (name text PRIMARY KEY, address map<timestamp, text>);
将数据插入到地图中
在将数据插入到地图中的元素时，输入所有的键：值对，用逗号在逗号之间以逗号分隔，如下所示。
cqlsh:tutorialspoint> INSERT INTO data3 (name, address)
VALUES ('robin', {'home' : 'hyderabad' , 'office' : 'Delhi' } );
更新集合
以下代码显示如何在名为data3的表中更新地图数据类型。在这里，我们改变了关键办公室的价值，也就是说，我们改变一个名为robin的人的办公地址。
cqlsh:tutorialspoint> UPDATE data3
... SET address = address+{'office':'mumbai'}
... WHERE name = 'robin';
验证
如果使用SELECT语句验证表，您将得到以下结果：
cqlsh:tutorialspoint> select * from data3;
name | address
-------+-------------------------------------------
robin | {'home': 'hyderabad', 'office': 'mumbai'}
(1 rows)
Cassandra CQL用户定义的数据类型
CQL提供了创建和使用用户定义的数据类型的功能。您可以创建一个数据类型来处理多个字段。本章介绍如何创建，更改和删除用户定义的数据类型。
创建用户定义的数据类型
命令CREATE TYPE用于创建用户定义的数据类型。其语法如下：
CREATE TYPE <keyspace name>. <data typename> ( variable1, variable2).
示例
下面给出了创建用户定义数据类型的示例。在此示例中，我们正在创建一个包含以下详细信息的card_details数据类型。
| 字段 | 字段名称 | 数据类型 |
|---|---|---|
| credit card no | num | int |
| credit card pin | pin | int |
| name on credit card | name | text |
| cvv | cvv | int |
| Contact details of card holder | phone | set |
cqlsh:tutorialspoint> CREATE TYPE card_details ( ... num int, ... pin int, ... name text, ... cvv int, ... phone set<int> ... );
注：用于用户定义数据类型的名称不应与保留类型名称一致。
验证
使用DESCRIBE命令验证是否已创建创建的类型。
CREATE TYPE tutorialspoint.card_details ( num int, pin int, name text, cvv int, phone set<int> );
更改用户定义的数据类型
ALTER TYPE命令用于更改现有数据类型。使用ALTER，您可以添加新字段或重命名现有字段。
将字段添加到类型
使用以下语法向现有用户定义的数据类型添加新字段。
ALTER TYPE typename ADD field_name field_type;
以下代码向Card_details数据类型添加了一个新字段。这里我们添加一个名为email的新字段。
cqlsh:tutorialspoint> ALTER TYPE card_details ADD email text;
验证
使用DESCRIBE命令验证是否添加新字段。
cqlsh:tutorialspoint> describe type card_details; CREATE TYPE tutorialspoint.card_details ( num int, pin int, name text, cvv int, phone set<int>, );
在类型中重命名字段
使用以下语法重命名现有的用户定义数据类型。
ALTER TYPE typename RENAME existing_name TO new_name;
以下代码更改类型中字段的名称。这里我们将字段电子邮件重命名为邮件。
cqlsh:tutorialspoint> ALTER TYPE card_details RENAME email TO mail;
验证
使用DESCRIBE命令验证类型名称是否已更改。
cqlsh:tutorialspoint> describe type card_details; CREATE TYPE tutorialspoint.card_details ( num int, pin int, name text, cvv int, phone set<int>, mail text );
删除用户定义的数据类型
DROP TYPE是用于删除用户定义的数据类型的命令。下面给出了一个删除用户定义数据类型的示例。
示例
在删除之前，使用DESCRIBE_TYPES命令验证所有用户定义的数据类型的列表，如下所示。
cqlsh:tutorialspoint> DESCRIBE TYPES; card_details card
从这两种类型中，删除名为card的类型，如下所示。
cqlsh:tutorialspoint> drop type card;
使用DESCRIBE命令验证数据类型是否丢失。
cqlsh:tutorialspoint> describe types; card_details
Cassandra 相关资源
以下资源包含有关Cassandra的其他信息。请使用它们获得有关此主题的更深入的知识。
Cassandra 相关链接
-
Cassandra - Cassandra官方网站。
-
Cassandra 维基百科 - Cassandra维基百科参考
Cassandra 相关书籍
Cassandra 相关讨论
Cassandra是一个来自Apache的分布式数据库，具有高度可扩展性，可用于管理大量的结构化数据。它提供高可用性，没有单点故障。本教程首先介绍Cassandra，然后是其架构，安装和重要的类和接口。此后，它将介绍如何使用CQLSH和Java API对键空间，表和索引执行诸如创建，更改，更新和删除操作。本教程还有专门的章节来解释CQL中可用的数据类型和集合，以及如何使用用户定义的数据类型。
1386
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
