Cassandra - 快速指南

---

Cassandra - 简介

Apache Cassandra 是一种高度可扩展、高性能的分布式数据库，旨在处理跨多个商用服务器的大量数据，提供高可用性且无单点故障。它是一种 NoSQL 数据库。首先让我们了解一下NoSQL数据库的作用。

NoSQL数据库

NoSQL 数据库（有时称为 Not Only SQL）是一种提供存储和检索数据而不是关系数据库中使用的表格关系的机制的数据库。这些数据库是无模式的，支持轻松复制，具有简单的API，最终一致，并且可以处理大量数据。

NoSQL 数据库的主要目标是

• 设计简单，
• 水平缩放，以及
• 更好地控制可用性。

与关系数据库相比，NoSql 数据库使用不同的数据结构。它使 NoSQL 中的某些操作更快。给定 NoSQL 数据库的适用性取决于它必须解决的问题。

NoSQL 与关系数据库

下表列出了关系数据库与 NoSQL 数据库的区别点。

除了 Cassandra 之外，我们还有以下非常流行的 NoSQL 数据库 -

• Apache HBase - HBase 是一个开源、非关系型、分布式数据库，模仿 Google 的 BigTable，并用 Java 编写。它是作为 Apache Hadoop 项目的一部分开发的，运行在 HDFS 之上，为 Hadoop 提供类似 BigTable 的功能。

• MongoDB - MongoDB 是一个跨平台的面向文档的数据库系统，它避免使用传统的基于表的关系数据库结构，而是使用具有动态模式的类似 JSON 的文档，使得某些类型的应用程序中的数据集成变得更容易和更快。

什么是 Apache Cassandra？

Apache Cassandra 是一个开源、分布式、去中心化/分布式存储系统（数据库），用于管理分布在世界各地的大量结构化数据。它提供高度可用的服务，没有单点故障。

下面列出了 Apache Cassandra 的一些值得注意的点 -

• 它具有可扩展性、容错性和一致性。

• 它是一个面向列的数据库。

• 其分布设计基于亚马逊的Dynamo及其基于谷歌Bigtable的数据模型。

• 它是 Facebook 创建的，与关系数据库管理系统有很大不同。

• Cassandra 实现了 Dynamo 风格的复制模型，没有单点故障，但添加了更强大的“列族”数据模型。

• Cassandra 被 Facebook、Twitter、Cisco、Rackspace、ebay、Twitter、Netflix 等一些最大的公司使用。

Cassandra的特点

Cassandra因其出色的技术特性而变得如此受欢迎。下面给出了 Cassandra 的一些功能：

• 弹性可扩展性- Cassandra 具有高度可扩展性；它允许根据要求添加更多硬件来容纳更多客户和更多数据。

• 始终在线架构- Cassandra 没有单点故障，并且对于无法承受故障的关键业务应用程序持续可用。

• 快速线性扩展性能- Cassandra 是线性可扩展的，即，当您增加集群中的节点数量时，它会增加您的吞吐量。因此它保持快速的响应时间。

• 灵活的数据存储- Cassandra 适应所有可能的数据格式，包括：结构化、半结构化和非结构化。它可以根据您的需要动态地适应数据结构的变化。

• 轻松的数据分发- Cassandra 通过跨多个数据中心复制数据，提供了在您需要的地方分发数据的灵活性。

• 事务支持- Cassandra 支持Atomics性、一致性、隔离性和持久性 (ACID) 等属性。

• 快速写入- Cassandra 被设计为在廉价的商品硬件上运行。它执行极快的写入速度，可以存储数百 TB 的数据，而不会牺牲读取效率。

Cassandra的历史

• Cassandra 是 Facebook 为收件箱搜索而开发的。
• 它于 2008 年 7 月由 Facebook 开源。
• Cassandra 于 2009 年 3 月被 Apache 孵化器接纳。
• 自 2010 年 2 月起，它被列为 Apache 顶级项目。

Cassandra - 架构

Cassandra 的设计目标是跨多个节点处理大数据工作负载，而不会出现任何单点故障。Cassandra 具有跨节点的点对点分布式系统，数据分布在集群中的所有节点之间。

• 集群中的所有节点都扮演相同的角色。每个节点都是独立的，同时又与其他节点互连。

• 集群中的每个节点都可以接受读写请求，无论数据实际位于集群中的哪个位置。

• 当节点出现故障时，可以从网络中的其他节点提供读/写请求。

Cassandra 中的数据复制

在 Cassandra 中，集群中的一个或多个节点充当给定数据片段的副本。如果检测到某些节点响应了过期值，Cassandra 将向客户端返回最新值。返回最新值后，Cassandra在后台执行读取修复以更新过时的值。

下图展示了Cassandra如何在集群中的节点之间使用数据复制来确保无单点故障的示意图。

注- Cassandra 在后台使用Gossip 协议来允许节点相互通信并检测集群中的任何故障节点。

Cassandra的组件

Cassandra 的关键组件如下 -

• 节点- 它是存储数据的地方。

• 数据中心- 它是相关节点的集合。

• 集群- 集群是包含一个或多个数据中心的组件。

• 提交日志- 提交日志是 Cassandra 中的崩溃恢复机制。每个写操作都会写入提交日志。

• Mem-table - mem-table 是内存驻留数据结构。提交日志后，数据将写入mem-table。有时，对于单列族，会有多个内存表。

• SSTable - 它是一个磁盘文件，当其内容达到阈值时，数据将从内存表中刷新到该文件。

• 布隆过滤器- 这些只不过是快速的、不确定的算法，用于测试元素是否是集合的成员。它是一种特殊的缓存。每次查询后都会访问布隆过滤器。

Cassandra 查询语言

用户可以使用 Cassandra 查询语言 (CQL) 通过其节点访问 Cassandra。CQL 将数据库（Keyspace）视为表的容器。程序员使用cqlsh：使用 CQL 或单独的应用程序语言驱动程序的提示。

客户端访问任何节点进行读写操作。该节点（协调器）在客户端和保存数据的节点之间充当代理。

写操作

节点的每个写入活动都会被节点中写入的提交日志捕获。稍后数据将被捕获并存储在内存表中。每当mem-table满了，数据就会被写入SStable数据文件。所有写入都会自动分区并在整个集群中复制。Cassandra 定期合并 SSTable，丢弃不必要的数据。

读操作

在读取操作期间，Cassandra 从内存表中获取值并检查布隆过滤器以找到保存所需数据的适当 SSTable。

Cassandra - 数据模型

Cassandra 的数据模型与我们通常在 RDBMS 中看到的数据模型有很大不同。本章概述了 Cassandra 如何存储其数据。

簇

Cassandra 数据库分布在一起运行的多台机器上。最外面的容器称为集群。对于故障处理，每个节点都包含一个副本，并且在发生故障时，由副本负责。Cassandra 将节点以环形格式排列在集群中，并向它们分配数据。

键空间

Keyspace 是 Cassandra 中最外层的数据容器。Cassandra 中键空间的基本属性是 -

• 复制因子- 集群中将接收相同数据副本的机器数量。

• 副本放置策略- 这只不过是在环中放置副本的策略。我们有简单策略（机架感知策略）、旧网络拓扑策略（机架感知策略）、网络拓扑策略（数据中心共享策略）等策略。

• 列族- 键空间是一个或多个列族列表的容器。反过来，列族是行集合的容器。每行包含有序列。列族代表数据的结构。每个键空间至少有一个并且通常有多个列族。

创建键空间的语法如下 -

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

下图显示了 Keyspace 的示意图。

列族

列族是有序行集合的容器。每行又是列的有序集合。下表列出了列族与关系数据库表的区别点。

Cassandra 列族具有以下属性 -

• keys_cached - 它表示每个 SSTable 保留缓存的位置数。

• rows_cached - 它表示其全部内容将被缓存在内存中的行数。

• preload_row_cache - 它指定是否要预填充行缓存。

注意 -与列族架构不固定的关系表不同，Cassandra 不会强制单个行拥有所有列。

下图显示了 Cassandra 列族的示例。

柱子

列是 Cassandra 的基本数据结构，具有三个值，即键或列名称、值和时间戳。下面给出的是列的结构。

超级柱

超级列是一种特殊的列，因此，它也是一个键值对。但是超级列存储子列的映射。

通常，列族存储在磁盘上的单个文件中。因此，为了优化性能，将可能一起查询的列保留在同一个列族中非常重要，超级列在这里会很有帮助。下面给出的是超级列的结构。

Cassandra 和 RDBMS 的数据模型

下表列出了 Cassandra 的数据模型与 RDBMS 的数据模型的区别点。

Cassandra - 安装

可以使用 cqlsh 以及不同语言的驱动程序来访问 Cassandra。本章介绍如何设置 cqlsh 和 java 环境以与 Cassandra 一起使用。

安装前设置

在Linux环境中安装Cassandra之前，我们需要使用ssh（Secure 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 <最新版本> - 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

可使用以下命令从下载链接Cassandra获取 Apache 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”

• save_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 的 Cassandra 主目录/home，然后运行以下命令来启动 Cassandra 服务器。

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

使用 –f 选项告诉 Cassandra 留在前台而不是作为后台进程运行。如果一切顺利，您可以看到 Cassandra 服务器启动。

编程环境

要以编程方式设置 Cassandra，请下载以下 jar 文件 -

• slf4j-api-1.7.5.jar
• Cassandra驱动程序核心-2.0.2.jar
• 番石榴-16.0.1.jar
• 指标-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 并创建一个名为 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包。

方法

集群生成器

该类用于实例化Cluster.Builder类。

方法

会议

该接口保存与 Cassandra 集群的连接。使用此接口，您可以执行CQL查询。它属于com.datastax.driver.core包。

方法

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 命令

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 命令显示所有 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 或从 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 及其对象的当前集群。下面解释了该命令的变体。

描述集群- 此命令提供有关集群的信息。

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] 

描述键空间- 此命令列出集群中的所有键空间。下面给出了该命令的用法。

cqlsh:tutorialspoint> describe keyspaces;

system_traces system tp tutorialspoint

描述表- 此命令列出键空间中的所有表。下面给出了该命令的用法。

cqlsh:tutorialspoint> describe tables;
emp

描述表- 此命令提供表的描述。下面给出了该命令的用法。

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 - 创建键空间

使用 Cqlsh 创建键空间

Cassandra 中的键空间是定义节点上数据复制的命名空间。集群的每个节点包含一个键空间。下面给出的是使用语句CREATE KEYSPACE创建键空间的语法。

句法

CREATE KEYSPACE <identifier> WITH <properties>

IE

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来更新当前 KeySpace。此选项不是强制性的，默认情况下，它设置为 true。

例子

下面给出了创建 KeySpace 的示例。

• 这里我们创建一个名为TutorialsPoint的KeySpace 。

• 我们使用第一个副本放置策略，即Simple Strategy。

• 我们选择复制因子为1 个副本。

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

确认

您可以使用命令Describe来验证该表是否已创建。如果您在键空间上使用此命令，它将显示创建的所有键空间，如下所示。

cqlsh> DESCRIBE keyspaces;

tutorialspoint system system_traces 

在这里您可以观察新创建的KeySpace教程点。

持久写入

默认情况下，表的 Durable_writes 属性设置为true，但也可以设置为 false。您不能将此属性设置为单纯形策略。

例子

下面给出的示例演示了持久写入属性的用法。

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

确认

您可以通过查询系统Keyspace来验证测试KeySpace的durable_writes属性是否设置为false。此查询为您提供所有 KeySpace 及其属性。

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。

使用键空间

您可以使用关键字USE来使用创建的 KeySpace 。其语法如下 -

Syntax:USE <identifier>

例子

在以下示例中，我们使用 KeySpace教程点。

cqlsh> USE tutorialspoint;
cqlsh:tutorialspoint>

使用 Java API 创建密钥空间

您可以使用Session类的execute()方法创建一个Keyspace 。按照下面给出的步骤使用 Java API 创建键空间。

Step1：创建集群对象

首先，创建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 - 更改键空间

改变KeySpace

ALTER KEYSPACE 可用于更改 KeySpace 的属性，例如副本数和持久写入数。下面给出了该命令的语法。

句法

ALTER KEYSPACE <identifier> WITH <properties>

IE

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

ALTER KEYSPACE的属性与 CREATE KEYSPACE 相同。它有两个属性：replication和Durable_writes。

复制

复制选项指定副本放置策略和所需副本的数量。

持久写入

使用此选项，您可以指示 Cassandra 是否使用 commitlog 来更新当前 KeySpace。此选项不是强制性的，默认情况下，它设置为 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 更改键空间

Step1：创建集群对象

首先，创建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 的键空间。我们正在将复制选项从简单策略更改为网络拓扑策略。

• 我们正在将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删除 KeySpace 。下面给出的是删除 KeySpace 的语法。

句法

DROP KEYSPACE <identifier>

IE

DROP KEYSPACE “KeySpace name”

例子

以下代码删除键空间教程点。

cqlsh> DROP KEYSPACE tutorialspoint;

确认

使用命令“Describe”验证键空间并检查表是否已删除，如下所示。

cqlsh> DESCRIBE keyspaces;

system system_traces

由于我们已经删除了密钥空间教程点，因此您将在密钥空间列表中找不到它。

使用 Java API 删除键空间

您可以使用Session类的execute()方法创建一个键空间。按照下面给出的步骤使用 Java API 删除键空间。

Step1：创建集群对象

首先，创建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 - 创建表

创建表

您可以使用命令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 中创建表的示例。我们在这里 -

• 使用键空间教程点

• 创建名为emp的表

它将包含员工姓名、身份证、城市、工资和电话号码等详细信息。员工 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)

在这里您可以观察使用给定列创建的表。由于我们已经删除了密钥空间教程点，因此您将在密钥空间列表中找不到它。

使用 Java API 创建表

您可以使用Session类的execute()方法创建一个表。按照下面给出的步骤使用 Java API 创建表。

Step1：创建集群对象

首先，创建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 步：创建会话对象

使用connect()<创建 Session 对象的实例