- Cassandra 教程
- Cassandra - 首页
- Cassandra - 简介
- Cassandra - 架构
- Cassandra - 数据模型
- Cassandra - 安装
- Cassandra - 参考 API
- Cassandra - Cqlsh
- Cassandra - Shell 命令
- Cassandra Keyspace 操作
- Cassandra - 创建 Keyspace
- Cassandra - 修改 Keyspace
- Cassandra - 删除 Keyspace
- Cassandra 表操作
- Cassandra - 创建表
- Cassandra - 修改表
- Cassandra - 删除表
- Cassandra - 清空表
- Cassandra - 创建索引
- Cassandra - 删除索引
- Cassandra - 批处理
- Cassandra CURD 操作
- Cassandra - 创建数据
- Cassandra - 更新数据
- Cassandra - 读取数据
- Cassandra - 删除数据
- Cassandra CQL 类型
- Cassandra - CQL 数据类型
- Cassandra - CQL 集合
- CQL 用户自定义数据类型
- Cassandra 有用资源
- Cassandra - 快速指南
- Cassandra - 有用资源
- Cassandra - 讨论
Cassandra - 快速指南
Cassandra - 简介
Apache Cassandra 是一个高度可扩展、高性能的分布式数据库，旨在跨多个商品服务器处理大量数据，提供高可用性且没有单点故障。它是一种 NoSQL 数据库。让我们首先了解一下 NoSQL 数据库的作用。
NoSQL 数据库
NoSQL 数据库（有时称为 Not Only 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、Twitter、Netflix 等。
Cassandra 的特性
Cassandra 因其出色的技术特性而变得如此受欢迎。以下是 Cassandra 的一些特性
弹性可扩展性 - Cassandra 是高度可扩展的；它允许根据需要添加更多硬件以容纳更多客户和更多数据。
始终在线架构 - Cassandra 没有单点故障，并且始终可用于无法承受故障的关键业务应用程序。
快速线性扩展性能 - Cassandra 是线性可扩展的，即随着集群中节点数量的增加，吞吐量也会增加。因此，它保持了快速的响应时间。
灵活的数据存储 - Cassandra 可以容纳所有可能的数据格式，包括：结构化、半结构化和非结构化。它可以根据您的需要动态适应数据结构的变化。
轻松的数据分发 - Cassandra 提供灵活性，可以将数据复制到多个数据中心，从而将数据分发到您需要的位置。
事务支持 - Cassandra 支持原子性、一致性、隔离性和持久性（ACID）等属性。
快速写入 - Cassandra 旨在运行在廉价的商品硬件上。它执行极快的写入，并且可以存储数百 TB 的数据，而不会牺牲读取效率。
Cassandra 的历史
- Cassandra 是在 Facebook 为收件箱搜索而开发的。
- 它于 2008 年 7 月由 Facebook 开源。
- Cassandra 于 2009 年 3 月被接受进入 Apache Incubator。
- 自 2010 年 2 月起，它成为 Apache 的顶级项目。
Cassandra - 架构
Cassandra 的设计目标是在多个节点上处理大数据工作负载，而没有任何单点故障。Cassandra 在其节点之间具有对等分布式系统，并且数据分布在集群中的所有节点之间。
集群中的所有节点都扮演相同的角色。每个节点都是独立的，同时又与其他节点互连。
集群中的每个节点都可以接受读写请求，而不管数据实际位于集群中的哪个位置。
当某个节点出现故障时，可以从网络中的其他节点提供读/写请求服务。
Cassandra 中的数据复制
在 Cassandra 中，集群中的一个或多个节点充当给定数据片段的副本。如果检测到某些节点响应了过时的值，Cassandra 将向客户端返回最新值。返回最新值后，Cassandra 会在后台执行读取修复以更新过时的值。
下图显示了 Cassandra 如何在集群中的节点之间使用数据复制以确保没有单点故障的示意图。
注意 - Cassandra 在后台使用Gossip 协议，允许节点相互通信并检测集群中的任何故障节点。
Cassandra 的组件
Cassandra 的关键组件如下：
节点 - 它是存储数据的位置。
数据中心 - 它是相关节点的集合。
集群 - 集群是一个包含一个或多个数据中心的组件。
提交日志 - 提交日志是 Cassandra 中的崩溃恢复机制。每个写入操作都会写入提交日志。
Mem-table - Mem-table 是一个驻留在内存中的数据结构。在提交日志之后，数据将写入 Mem-table。有时，对于单个列族，将存在多个 Mem-table。
SSTable - 它是将数据从 Mem-table 刷出到磁盘的文件，当其内容达到阈值时。
布隆过滤器 - 这些只不过是快速、非确定性的算法，用于测试元素是否为集合的成员。它是一种特殊的缓存。在每次查询后都会访问布隆过滤器。
Cassandra 查询语言
用户可以通过其节点使用 Cassandra 查询语言 (CQL) 访问 Cassandra。CQL 将数据库(Keyspace)视为表的容器。程序员使用cqlsh: 提示符来使用 CQL 或单独的应用程序语言驱动程序。
客户端为其读写操作联系任何节点。该节点（协调器）充当客户端和保存数据的节点之间的代理。
写入操作
节点的每个写入活动都由写入节点的提交日志捕获。稍后将捕获数据并存储在Mem-table中。每当 Mem-table 满了时，数据将写入SStable数据文件。所有写入都会自动分区并在整个集群中复制。Cassandra 定期合并 SSTable，丢弃不必要的数据。
读取操作
在读取操作期间，Cassandra 从 Mem-table 获取值并检查布隆过滤器以找到保存所需数据的适当 SSTable。
Cassandra - 数据模型
Cassandra 的数据模型与我们在 RDBMS 中通常看到的模型有很大不同。本章概述了 Cassandra 如何存储其数据。
集群
Cassandra 数据库分布在多台协同工作的机器上。最外层的容器称为集群。为了处理故障，每个节点都包含一个副本，并且在发生故障时，副本将接管。Cassandra 以环形格式在集群中排列节点，并将数据分配给它们。
Keyspace
Keyspace 是 Cassandra 中数据的最外层容器。Cassandra 中 Keyspace 的基本属性有：
复制因子 - 它是集群中将接收相同数据副本的机器数量。
副本放置策略 - 这只不过是在环中放置副本的策略。我们有诸如简单策略（机架感知策略）、旧网络拓扑策略（机架感知策略）和网络拓扑策略（数据中心共享策略）等策略。
列族 - Keyspace 是一个或多个列族的容器。反过来，列族是行集合的容器。每一行都包含有序的列。列族表示数据的结构。每个 Keyspace 至少有一个，通常有多个列族。
创建 Keyspace 的语法如下：
CREATE KEYSPACE Keyspace name
WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 3};
下图显示了 Keyspace 的示意图。
列族
列族是有序行集合的容器。反过来，每一行都是有序列的集合。下表列出了区分列族和关系数据库表的要点。
| 关系表 | 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 中，表是数组的数组。（行 x 列） | 在 Cassandra 中，表是“嵌套键值对”的列表。（行 x 列键 x 列值） |
| 数据库是最外层的容器，包含与应用程序对应的数据。 | Keyspace 是最外层的容器，包含与应用程序对应的数据。 |
| 表是数据库的实体。 | 表或列族是 keyspace 的实体。 |
| 行是 RDBMS 中的单个记录。 | 行是 Cassandra 中的复制单元。 |
| 列表示关系的属性。 | 列是 Cassandra 中的存储单元。 |
| RDBMS 支持外键、连接的概念。 | 关系使用集合表示。 |
Cassandra - 安装
Cassandra 可以使用 cqlsh 以及不同语言的驱动程序进行访问。本章介绍如何设置 cqlsh 和 java 环境以使用 Cassandra。
安装前设置
在 Linux 环境中安装 Cassandra 之前，我们需要使用 **ssh**（安全外壳）设置 Linux。请按照以下步骤设置 Linux 环境。
创建用户
首先，建议为 Hadoop 创建一个单独的用户，以将 Hadoop 文件系统与 Unix 文件系统隔离。请按照以下步骤创建用户。
使用命令 **“su”** 打开 root。
使用命令 **“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 <最新版本> - X64.tar.gz）：链接
然后 jdk-7u71-linux-x64.tar.gz 将下载到您的系统上。
步骤 2
通常，您会在 Downloads 文件夹中找到下载的 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./log/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 的新项目。
右键单击该项目，选择 **Build Path→Configure Build Path**，如下所示。
它将打开属性窗口。在“库”选项卡下，选择 **添加外部 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 中所有重要的类。
集群
此类是驱动程序的主要入口点。它属于 **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() 此方法使用给定的联系点构建集群。 |
Session
此接口保存与 Cassandra 集群的连接。使用此接口，您可以执行 **CQL** 查询。它属于 **com.datastax.driver.core** 包。
方法
| 序号 | 方法和描述 |
|---|---|
| 1 | void close() 此方法用于关闭当前会话实例。 |
| 2 | ResultSet execute(Statement statement) 此方法用于执行查询。它需要一个语句对象。 |
| 3 | ResultSet execute(String query) 此方法用于执行查询。它需要一个以字符串对象形式存在的查询。 |
| 4 | PreparedStatement prepare(RegularStatement statement) 此方法准备提供的查询。查询需要以语句的形式提供。 |
| 5 | PreparedStatement prepare(String query) 此方法准备提供的查询。查询需要以字符串的形式提供。 |
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= **“文件名”** | 如果您使用此选项，Cassandra 将执行给定文件中的命令并退出。 |
| cqlsh --no-color | 指示 Cassandra 不要使用彩色输出。 |
| cqlsh -u **“用户名”** | 使用此选项，您可以对用户进行身份验证。默认用户名为：cassandra。 |
| cqlsh-p **“密码”** | 使用此选项，您可以使用密码对用户进行身份验证。默认密码为：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 − 更改键空间的属性。
DROP KEYSPACE − 删除键空间。
CREATE TABLE − 在键空间中创建一个表。
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 命令显示所有 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
捕获
此命令捕获命令的输出并将其添加到文件中。例如，查看以下捕获输出到名为Outputfile的文件的代码。
cqlsh> CAPTURE '/home/hadoop/CassandraProgs/Outputfile'
当我们在终端中键入任何命令时，输出将被给定的文件捕获。以下是使用的命令和输出文件的快照。
cqlsh:tutorialspoint> select * from emp;
您可以使用以下命令关闭捕获。
cqlsh:tutorialspoint> capture off;
一致性
此命令显示当前一致性级别，或设置新的一致性级别。
cqlsh:tutorialspoint> CONSISTENCY Current consistency level is 1.
复制
此命令在 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.
如果打开并验证给定的文件，您可以在下面看到已复制的数据。
描述
此命令描述 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 table − 此命令提供表的描述。以下是此命令的使用方法。
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);
描述类型
此命令用于描述用户定义的数据类型。以下是此命令的使用方法。
cqlsh:tutorialspoint> describe type card_details; CREATE TYPE tutorialspoint.card_details ( num int, pin int, name text, cvv int, phone set<int>, mail text );
描述类型
此命令列出所有用户定义的数据类型。以下是此命令的使用方法。假设有两个用户定义的数据类型：card 和 card_details。
cqlsh:tutorialspoint> DESCRIBE TYPES; card_details card
扩展
此命令用于扩展输出。在使用此命令之前，您必须打开扩展命令。以下是此命令的使用方法。
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.
退出
此命令用于终止 cql shell。
显示
此命令显示当前 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]
源
使用此命令，您可以执行文件中的命令。假设我们的输入文件如下所示：
然后，您可以执行包含命令的文件，如下所示。
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 - 创建 Keyspace
使用 Cqlsh 创建键空间
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 是否对当前键空间的更新使用commitlog。此选项不是必需的，默认情况下设置为 true。
示例
以下是创建键空间的示例。
这里我们正在创建一个名为TutorialsPoint的键空间。
我们使用第一个副本放置策略，即简单策略。
并且我们选择复制因子为1 个副本。
cqlsh.> CREATE KEYSPACE tutorialspoint
WITH replication = {'class':'SimpleStrategy', 'replication_factor' : 3};
验证
您可以使用命令Describe验证表是否已创建。如果您在键空间上使用此命令，它将显示如下所示的所有已创建的键空间。
cqlsh> DESCRIBE keyspaces; tutorialspoint system system_traces
在这里，您可以观察到新创建的键空间tutorialspoint。
Durable_writes
默认情况下，表的 durable_writes 属性设置为true，但可以设置为 false。您不能将此属性设置为simplex 策略。
示例
以下是演示 durable writes 属性用法的示例。
cqlsh> CREATE KEYSPACE test
... WITH REPLICATION = { 'class' : 'NetworkTopologyStrategy', 'datacenter1' : 3 }
... AND DURABLE_WRITES = false;
验证
您可以通过查询 System 键空间来验证 test 键空间的 durable_writes 属性是否已设置为 false。此查询为您提供所有键空间及其属性。
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)
在这里，您可以观察到 test 键空间的 durable_writes 属性已设置为 false。
使用键空间
您可以使用关键字USE使用已创建的键空间。其语法如下：
Syntax:USE <identifier>
示例
在以下示例中，我们正在使用键空间tutorialspoint。
cqlsh> USE tutorialspoint; cqlsh:tutorialspoint>
使用 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" );
使用新的 builder 对象，创建一个集群对象。为此，您在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的键空间。我们使用第一个副本放置策略，即简单策略，并且我们选择复制因子为 1 个副本。
您必须将查询存储在字符串变量中并将其传递给 execute() 方法，如下所示。
String query = "CREATE KEYSPACE tp WITH replication "
+ "= {'class':'SimpleStrategy', 'replication_factor':1}; ";
session.execute(query);
步骤 4：使用键空间
您可以使用 execute() 方法使用已创建的键空间，如下所示。
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 - 修改 Keyspace
更改键空间
ALTER KEYSPACE 可用于更改键空间的属性，例如副本数量和 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 是否对当前键空间的更新使用 commitlog。此选项不是必需的，默认情况下设置为 true。
示例
以下是更改键空间的示例。
这里我们正在更改名为TutorialsPoint的键空间。
我们将复制因子从 1 更改为 3。
cqlsh.> ALTER KEYSPACE tutorialspoint
WITH replication = {'class':'NetworkTopologyStrategy', 'replication_factor' : 3};
更改 Durable_writes
您还可以更改键空间的 durable_writes 属性。以下是test键空间的 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;
再次，如果您验证键空间的属性，它将产生以下输出。
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" );
使用新的 builder 对象，创建一个集群对象。为此，您在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的键空间。我们正在将复制选项从简单策略更改为网络拓扑策略。
我们正在将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 - 删除 Keyspace
删除键空间
您可以使用命令DROP KEYSPACE删除键空间。以下是删除键空间的语法。
语法
DROP KEYSPACE <identifier>
例如
DROP KEYSPACE “KeySpace name”
示例
以下代码删除键空间tutorialspoint。
cqlsh> DROP KEYSPACE tutorialspoint;
验证
使用命令Describe验证键空间并检查表是否已删除，如下所示。
cqlsh> DESCRIBE keyspaces; system system_traces
由于我们已删除键空间 tutorialspoint，因此您不会在键空间列表中找到它。
使用 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" );
使用新的 builder 对象，创建一个集群对象。为此，您在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 - 创建表
创建表
您可以使用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) )
示例
以下是在 Cassandra 中使用 cqlsh 创建表的示例。这里我们：
使用 keyspace tutorialspoint
创建名为emp的表
它将包含诸如员工姓名、ID、城市、薪资和电话号码等详细信息。员工 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 tutorialspoint，您将无法在 keyspaces 列表中找到它。
使用 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" );
使用新的 builder 对象，创建一个集群对象。为此，您在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的 keyspace。因此，创建 Session 对象，如下所示。
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 - 修改表
更改表
您可以使用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" );
使用新的 builder 对象，创建一个集群对象。为此，您在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，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“ Your keyspace name ” ); Session session = cluster.connect(“ tp” );
这里我们使用名为 tp 的 KeySpace。因此，创建 Session 对象，如下所示。
步骤 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 - 删除表
删除表
您可以使用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：创建集群对象
首先，创建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" );
使用新的 builder 对象，创建一个集群对象。为此，您在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，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“Your keyspace name”);
这里我们使用名为tp的 keyspace。因此，创建 Session 对象，如下所示。
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 - 清空表
截断表
您可以使用 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语句验证表是否已截断。以下是截断后对 student 表执行 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" );
使用新的 builder 对象，创建一个集群对象。为此，您在Cluster.Builder类中有一个名为build()的方法。以下代码显示了如何创建集群对象。
//Building a cluster Cluster cluster = builder.build();
您可以使用一行代码构建集群对象，如下所示。
Cluster cluster = Cluster.builder().addContactPoint("127.0.0.1").build();
步骤 2：创建 Session 对象
使用 Cluster 类的 connect() 方法创建 Session 对象的实例，如下所示。
Session session = cluster.connect( );
此方法创建一个新会话并对其进行初始化。如果您已经拥有 keyspace，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“ Your keyspace name ” ); Session session = cluster.connect(“ tp” );
这里我们使用名为 tp 的 keyspace。因此，创建 Session 对象，如下所示。
步骤 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() 方法向表的列创建索引。请按照以下步骤向表中的列创建索引。
步骤 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" );
使用新的 builder 对象，创建一个集群对象。为此，您在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，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
这里我们使用名为tp的 KeySpace。因此，创建 Session 对象，如下所示。
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 - 删除索引
删除索引
您可以使用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" );
使用新的 builder 对象，创建一个集群对象。为此，您在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，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
这里我们使用名为tp的 KeySpace。因此，创建 Session 对象，如下所示。
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 - 批处理语句
使用批处理语句
使用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)。
- 将行 ID 为 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，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“ Your keyspace name ”);
这里我们使用名为 tp 的键空间。因此，请按如下所示创建会话对象。
Session session = cluster.connect(“tp”);
步骤 3：执行查询
您可以使用 Session 类的 execute() 方法执行 CQL 查询。将查询以字符串格式或作为 Statement 类对象传递给 execute() 方法。您以字符串格式传递给此方法的任何内容都将在cqlsh上执行。
在此示例中，我们将执行以下操作：
- 插入具有以下详细信息的新行 (4, rajeev, pune, 9848022331, 30000)。
- 将行 ID 为 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 - 创建数据
在表中创建数据
您可以使用 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");
使用新的 builder 对象，创建一个集群对象。为此，您在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，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“ Your keyspace name ” );
这里我们使用名为 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 - 更新数据
更新表中的数据
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，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“ Your keyspace name”);
这里我们使用名为 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 子句读取数据
SELECT 子句用于从 Cassandra 中的表读取数据。使用此子句，您可以读取整个表、单个列或特定单元格。以下是 SELECT 子句的语法。
SELECT FROM <tablename>
示例
假设键空间中有一个名为 emp 的表，包含以下详细信息：
| emp_id | emp_name | emp_city | emp_phone | emp_sal |
|---|---|---|---|---|
| 1 | ram | Hyderabad | 9848022338 | 50000 |
| 2 | robin | 空 | 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，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“Your keyspace name”);
这里我们使用名为 tp 的键空间。因此，请按如下所示创建会话对象。
Session session = cluster.connect(“tp”);
步骤 3：执行查询
您可以使用 Session 类的 execute() 方法执行 CQL 查询。将查询以字符串格式或作为 Statement 类对象传递给 execute() 方法。您以字符串格式传递给此方法的任何内容都将在cqlsh上执行。
在此示例中，我们正在从 emp 表中检索数据。将查询存储在字符串中，并将其作为参数传递给 session 类的 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 - 读取数据
使用 Select 子句读取数据
SELECT 子句用于从 Cassandra 中的表读取数据。使用此子句，您可以读取整个表、单个列或特定单元格。以下是 SELECT 子句的语法。
SELECT FROM <tablename>
示例
假设键空间中有一个名为 emp 的表，包含以下详细信息：
| emp_id | emp_name | emp_city | emp_phone | emp_sal |
|---|---|---|---|---|
| 1 | ram | Hyderabad | 9848022338 | 50000 |
| 2 | robin | 空 | 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，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“Your keyspace name”);
这里我们使用名为 tp 的键空间。因此，请按如下所示创建会话对象。
Session session = cluster.connect(“tp”);
步骤 3：执行查询
您可以使用 Session 类的 execute() 方法执行 CQL 查询。将查询以字符串格式或作为 Statement 类对象传递给 execute() 方法。您以字符串格式传递给此方法的任何内容都将在cqlsh上执行。
在此示例中，我们正在从 emp 表中检索数据。将查询存储在字符串中，并将其作为参数传递给 session 类的 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 - 删除数据
从表中删除数据
您可以使用 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();
此方法创建一个新会话并对其进行初始化。如果您已经拥有 keyspace，则可以通过将 KeySpace 名称以字符串格式传递给此方法来将其设置为现有的 keyspace，如下所示。
Session session = cluster.connect(“ Your keyspace name ”);
这里我们使用名为 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 | 字符串 | 表示 ASCII 字符串 |
| bigint | bigint | 表示 64 位有符号长整数 |
| blob | blob | 表示任意字节 |
| Boolean | 布尔值 | 表示真或假 |
| counter | 整数 | 表示计数器列 |
| decimal | 整数、浮点数 | 表示可变精度的十进制数 |
| double | 整数 | 表示 64 位 IEEE-754 浮点数 |
| float | 整数、浮点数 | 表示 32 位 IEEE-754 浮点数 |
| inet | 字符串 | 表示 IP 地址，IPv4 或 IPv6 |
| int | 整数 | 表示 32 位有符号整数 |
| text | 字符串 | 表示 UTF8 编码的字符串 |
| timestamp | 整数、字符串 | 表示时间戳 |
| timeuuid | uuid | 表示类型 1 UUID |
| uuid | uuid | 表示类型 1 或类型 4 |
| UUID | ||
| varchar | 字符串 | 表示 uTF8 编码的字符串 |
| varint | 整数 | 表示任意精度的整数 |
集合类型
Cassandra 查询语言还提供了集合数据类型。下表提供了 CQL 中可用的集合的列表。
| 集合 | 描述 |
|---|---|
| list | 列表是一个或多个有序元素的集合。 |
| map | 映射是键值对的集合。 |
| set | 集合是一个或多个元素的集合。 |
用户定义的数据类型
Cqlsh 为用户提供了创建自己的数据类型的功能。以下是处理用户定义的数据类型时使用的命令。
CREATE TYPE - 创建用户定义的数据类型。
ALTER TYPE - 修改用户定义的数据类型。
DROP TYPE - 删除用户定义的数据类型。
DESCRIBE TYPE - 描述用户定义的数据类型。
DESCRIBE TYPES - 描述用户定义的数据类型。
Cassandra - CQL 集合
CQL 提供了使用集合数据类型的功能。使用这些集合类型，您可以在单个变量中存储多个值。本章介绍如何在 Cassandra 中使用集合。
列表
列表用于以下情况：
- 需要维护元素的顺序，并且
- 需要多次存储值。
您可以使用列表中元素的索引获取列表数据类型的值。
创建带列表的表
以下是一个创建示例表的例子，该表有两个列，name 和 email。为了存储多个电子邮件，我们使用列表。
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的表
以下示例创建一个包含两列的示例表，名称和电话。为了存储多个电话号码，我们使用set。
cqlsh:tutorialspoint> CREATE TABLE data2 (name text PRIMARY KEY, phone set<varint>);
将数据插入Set
将数据插入集合中的元素时，请在花括号 { } 内以逗号分隔输入所有值，如下所示。
cqlsh:tutorialspoint> INSERT INTO data2(name, phone)VALUES ('rahman', {9848022338,9848022339});
更新Set
以下代码显示了如何在名为data2的表中更新set。这里我们向set中添加了另一个电话号码。
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的表
以下示例显示了如何创建一个包含两列的示例表，名称和地址。为了存储多个地址值，我们使用map。
cqlsh:tutorialspoint> CREATE TABLE data3 (name text PRIMARY KEY, address map<timestamp, text>);
将数据插入Map
将数据插入映射中的元素时，请在花括号 { } 内以逗号分隔输入所有键：值对，如下所示。
cqlsh:tutorialspoint> INSERT INTO data3 (name, address)
VALUES ('robin', {'home' : 'hyderabad' , 'office' : 'Delhi' } );
更新Set
以下代码显示了如何在名为data3的表中更新map数据类型。这里我们正在更改键office的值，即我们正在更改名为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数据类型。
| 字段 | 字段名称 | 数据类型 |
|---|---|---|
| 信用卡号 | num | int |
| 信用卡密码 | pin | int |
| 信用卡上的姓名 | name | text |
| cvv | cvv | int |
| 持卡人联系方式 | 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;
以下代码更改类型中字段的名称。这里我们正在将字段email重命名为mail。
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