Cassandra 文档

版本

您正在查看预发布版本的文档。

批量加载

不同的工具支持批量加载 Apache Cassandra 数据。要批量加载的数据必须以 SSTable 的形式存在。Cassandra 不支持直接加载其他格式的数据,例如 CSV、JSON 和 XML。虽然 cqlsh 的 COPY 命令可以加载 CSV 数据,但它不是处理大量数据的理想选择。批量加载用于

  • 恢复增量备份和快照。备份和快照已经以 SSTable 的形式存在。

  • 将现有 SSTable 加载到另一个集群。数据可以具有不同的节点数量或复制策略。

  • 将外部数据加载到集群。

批量加载工具

Cassandra 提供了两种用于批量加载数据的命令或工具

  • Cassandra 批量加载器,也称为 sstableloader

  • nodetool import 命令

如果 Cassandra 安装的 bin 目录在 PATH 环境变量中,则可以访问 sstableloadernodetool import。或者,可以直接从 bin 目录访问它们。这些示例使用在 备份 中创建的键空间和表。

使用 sstableloader

sstableloader 是用于批量上传数据的首要工具。sstableloader 将 SSTable 数据文件流式传输到正在运行的集群,符合复制策略和复制因子。要上传数据的表不需要为空。

运行 sstableloader 的唯一要求是

  • 一个或多个逗号分隔的初始主机,用于连接并获取环信息

  • 要加载的 SSTable 的目录路径

sstableloader [options] <dir_path>

Sstableloader 将 <dir_path> 目录中找到的 SSTable 批量加载到配置的集群。<dir_path> 用作目标键空间/表名称。例如,要将名为 Standard1-g-1-Data.db 的 SSTable 加载到 Keyspace1/Standard1,您需要在 /path/to/Keyspace1/Standard1/ 目录中拥有 Standard1-g-1-Data.dbStandard1-g-1-Index.db 文件。

Sstableloader 选项以接受目标键空间名称

通常作为备份策略的一部分,一些 Cassandra DBA 会存储整个数据目录。当发现数据中的损坏时,在同一个集群(对于大型集群,200 个节点)中恢复数据很常见,但使用不同的键空间名称。

目前 sstableloader 从文件夹结构中推断出键空间名称。作为一种选择,为了将目标键空间名称指定为 sstableloader 的一部分,版本 4.0 添加了对 --target-keyspace 选项的支持 (CASSANDRA-13884).

支持以下选项,其中 -d,--nodes <initial hosts> 是必需的

-alg,--ssl-alg <ALGORITHM>                                   Client SSL: algorithm

-ap,--auth-provider <auth provider>                          Custom
                                                             AuthProvider class name for
                                                             cassandra authentication
-ciphers,--ssl-ciphers <CIPHER-SUITES>                       Client SSL:
                                                             comma-separated list of
                                                             encryption suites to use
-cph,--connections-per-host <connectionsPerHost>             Number of
                                                             concurrent connections-per-host.
-d,--nodes <initial hosts>                                   Required.
                                                             Try to connect to these hosts (comma separated) initially for ring information

--entire-sstable-throttle-mib <throttle-mib>                 Entire SSTable throttle
                                                             speed in MiB/s (default 0 for unlimited).

--entire-sstable-inter-dc-throttle-mib                       <inter-dc-throttle-mib>
                                                             Entire SSTable inter-datacenter throttle
                                                             speed in MiB/s (default 0 for unlimited).

-f,--conf-path <path to config file>                         cassandra.yaml file path for streaming throughput and client/server SSL.

-h,--help                                                    Display this help message

-i,--ignore <NODES>                                          Don't stream to this (comma separated) list of nodes

-idct,--inter-dc-throttle <inter-dc-throttle>                (deprecated) Inter-datacenter throttle speed in Mbits (default 0 for unlimited).
                                                             Use --inter-dc-throttle-mib instead.

--inter-dc-throttle-mib <inter-dc-throttle-mib>              Inter-datacenter throttle speed in MiB/s (default 0 for unlimited)

-k,--target-keyspace <target keyspace name>                  Target
                                                             keyspace name
-ks,--keystore <KEYSTORE>                                    Client SSL:
                                                             full path to keystore
-kspw,--keystore-password <KEYSTORE-PASSWORD>                Client SSL:
                                                             password of the keystore
--no-progress                                                Don't
                                                             display progress
-p,--port <native transport port>                            Port used
                                                             for native connection (default 9042)
-prtcl,--ssl-protocol <PROTOCOL>                             Client SSL:
                                                             connections protocol to use (default: TLS)
-pw,--password <password>                                    Password for
                                                             cassandra authentication
-sp,--storage-port <storage port>                            Port used
                                                             for internode communication (default 7000)
-spd,--server-port-discovery <allow server port discovery>   Use ports
                                                             published by server to decide how to connect. With SSL requires StartTLS
                                                             to be used.
-ssp,--ssl-storage-port <ssl storage port>                   Port used
                                                             for TLS internode communication (default 7001)
-st,--store-type <STORE-TYPE>                                Client SSL:
                                                             type of store
-t,--throttle <throttle>                                     (deprecated) Throttle speed in Mbits (default 0 for unlimited).
                                                             Use --throttle-mib instead.
--throttle-mib <throttle-mib>                                Throttle
                                                             speed in MiB/s (default 0 for unlimited)
-ts,--truststore <TRUSTSTORE>                                Client SSL:
                                                             full path to truststore
-tspw,--truststore-password <TRUSTSTORE-PASSWORD>            Client SSL:
                                                             Password of the truststore
-u,--username <username>                                     Username for
                                                             cassandra authentication
-v,--verbose                                                 verbose
                                                             output

可以使用 -f 选项在命令行中提供 cassandra.yaml 文件,以设置流式传输吞吐量、客户端和服务器加密选项。仅从 cassandra.yaml 文件中读取 stream_throughput_outbound_megabits_per_secserver_encryption_optionsclient_encryption_options。您可以使用相应的命令行选项覆盖从 cassandra.yaml 文件中读取的选项。

sstableloader 演示

一个示例展示了如何使用 sstableloader 上传 catalogkeyspace.magazine 表的增量备份数据。此外,还创建了同一个表的快照,也使用 sstableloader 进行批量上传。

catalogkeyspace.magazine 表的备份和快照列出如下

$ cd ./cassandra/data/data/catalogkeyspace/magazine-446eae30c22a11e9b1350d927649052c && ls -l

结果为

total 0
drwxrwxr-x. 2 ec2-user ec2-user 226 Aug 19 02:38 backups
drwxrwxr-x. 4 ec2-user ec2-user  40 Aug 19 02:45 snapshots

使用 sstableloader 上传 SSTable 的目录路径结构用作目标键空间/表。如果目录结构采用 sstableloader 使用的格式,您可以分别直接从 backupssnapshots 目录上传。但 SSTable 的备份和快照的目录路径分别为 /catalogkeyspace/magazine-446eae30c22a11e9b1350d927649052c/backups/catalogkeyspace/magazine-446eae30c22a11e9b1350d927649052c/snapshots,不能用于将 SSTable 上传到 catalogkeyspace.magazine 表。目录路径结构必须为 /catalogkeyspace/magazine/ 才能使用 sstableloader。创建一个新的目录结构以使用 sstableloader 上传 SSTable,该结构位于 /catalogkeyspace/magazine,并设置适当的权限。

$ sudo mkdir -p /catalogkeyspace/magazine
$ sudo chmod -R 777 /catalogkeyspace/magazine

从增量备份中批量加载

增量备份不包含表的 DDL;表必须已经存在。如果表被删除,可以使用每次对表进行快照时生成的 schema.cql 文件来创建该表。在使用 sstableloader 将 SSTable 加载到 magazine 表之前,该表必须存在。该表不需要为空,但我们使用了一个空表,如 CQL 查询所示

SELECT * FROM magazine;

结果为

id | name | publisher
----+------+-----------

(0 rows)

创建要上传到的表后,将 SSTable 文件从 backups 目录复制到 /catalogkeyspace/magazine/ 目录。

$ sudo cp ./cassandra/data/data/catalogkeyspace/magazine-446eae30c22a11e9b1350d927649052c/backups/* \
/catalogkeyspace/magazine/

运行 sstableloader 以从 /catalogkeyspace/magazine/ 目录上传 SSTable。

$ sstableloader --nodes 10.0.2.238  /catalogkeyspace/magazine/

sstableloader 命令的输出应类似于以下列表

$ sstableloader --nodes 10.0.2.238  /catalogkeyspace/magazine/

结果为

Opening SSTables and calculating sections to stream
Streaming relevant part of /catalogkeyspace/magazine/na-1-big-Data.db
/catalogkeyspace/magazine/na-2-big-Data.db  to [35.173.233.153:7000, 10.0.2.238:7000,
54.158.45.75:7000]
progress: [35.173.233.153:7000]0:1/2 88 % total: 88% 0.018KiB/s (avg: 0.018KiB/s)
progress: [35.173.233.153:7000]0:2/2 176% total: 176% 33.807KiB/s (avg: 0.036KiB/s)
progress: [35.173.233.153:7000]0:2/2 176% total: 176% 0.000KiB/s (avg: 0.029KiB/s)
progress: [35.173.233.153:7000]0:2/2 176% [10.0.2.238:7000]0:1/2 39 % total: 81% 0.115KiB/s
(avg: 0.024KiB/s)
progress: [35.173.233.153:7000]0:2/2 176% [10.0.2.238:7000]0:2/2 78 % total: 108%
97.683KiB/s (avg: 0.033KiB/s)
progress: [35.173.233.153:7000]0:2/2 176% [10.0.2.238:7000]0:2/2 78 %
[54.158.45.75:7000]0:1/2 39 % total: 80% 0.233KiB/s (avg: 0.040KiB/s)
progress: [35.173.233.153:7000]0:2/2 176% [10.0.2.238:7000]0:2/2 78 %
[54.158.45.75:7000]0:2/2 78 % total: 96% 88.522KiB/s (avg: 0.049KiB/s)
progress: [35.173.233.153:7000]0:2/2 176% [10.0.2.238:7000]0:2/2 78 %
[54.158.45.75:7000]0:2/2 78 % total: 96% 0.000KiB/s (avg: 0.045KiB/s)
progress: [35.173.233.153:7000]0:2/2 176% [10.0.2.238:7000]0:2/2 78 %
[54.158.45.75:7000]0:2/2 78 % total: 96% 0.000KiB/s (avg: 0.044KiB/s)

sstableloader 完成数据加载后,运行查询 magazine 表以检查

SELECT * FROM magazine;

结果为

id | name                      | publisher
----+---------------------------+------------------
 1 |        Couchbase Magazine |        Couchbase
 0 | Apache Cassandra Magazine | Apache Cassandra

(2 rows)

从快照中批量加载

将表的快照还原到同一个表可以轻松完成

如果加载 SSTable 到 catalogkeyspace.magazine 所需的目录结构不存在,请创建这些目录并设置适当的权限

$ sudo mkdir -p /catalogkeyspace/magazine
$ sudo chmod -R 777 /catalogkeyspace/magazine

从目录中删除任何文件,以便可以复制快照文件而不会发生干扰

$ sudo rm /catalogkeyspace/magazine/*
$ cd /catalogkeyspace/magazine/
$ ls -l

结果为

total 0

将快照文件复制到 /catalogkeyspace/magazine 目录。

$ sudo cp ./cassandra/data/data/catalogkeyspace/magazine-446eae30c22a11e9b1350d927649052c/snapshots/magazine/* \
/catalogkeyspace/magazine

列出 /catalogkeyspace/magazine 目录中的文件。schema.cql 也将列出。

$ cd /catalogkeyspace/magazine && ls -l

结果为

total 44
-rw-r--r--. 1 root root   31 Aug 19 04:13 manifest.json
-rw-r--r--. 1 root root   47 Aug 19 04:13 na-1-big-CompressionInfo.db
-rw-r--r--. 1 root root   97 Aug 19 04:13 na-1-big-Data.db
-rw-r--r--. 1 root root   10 Aug 19 04:13 na-1-big-Digest.crc32
-rw-r--r--. 1 root root   16 Aug 19 04:13 na-1-big-Filter.db
-rw-r--r--. 1 root root   16 Aug 19 04:13 na-1-big-Index.db
-rw-r--r--. 1 root root 4687 Aug 19 04:13 na-1-big-Statistics.db
-rw-r--r--. 1 root root   56 Aug 19 04:13 na-1-big-Summary.db
-rw-r--r--. 1 root root   92 Aug 19 04:13 na-1-big-TOC.txt
-rw-r--r--. 1 root root  815 Aug 19 04:13 schema.cql

或者,创建指向快照文件夹的符号链接,而不是复制数据

$ mkdir <keyspace_name>
$ ln -s <path_to_snapshot_folder> <keyspace_name>/<table_name>

如果 magazine 表被删除,请运行 schema.cql 中的 DDL 以创建该表。使用以下命令运行 sstableloader

$ sstableloader --nodes 10.0.2.238  /catalogkeyspace/magazine/

如命令输出所示,SSTable 被流式传输到集群

Established connection to initial hosts
Opening SSTables and calculating sections to stream
Streaming relevant part of /catalogkeyspace/magazine/na-1-big-Data.db  to
[35.173.233.153:7000, 10.0.2.238:7000, 54.158.45.75:7000]
progress: [35.173.233.153:7000]0:1/1 176% total: 176% 0.017KiB/s (avg: 0.017KiB/s)
progress: [35.173.233.153:7000]0:1/1 176% total: 176% 0.000KiB/s (avg: 0.014KiB/s)
progress: [35.173.233.153:7000]0:1/1 176% [10.0.2.238:7000]0:1/1 78 % total: 108% 0.115KiB/s
(avg: 0.017KiB/s)
progress: [35.173.233.153:7000]0:1/1 176% [10.0.2.238:7000]0:1/1 78 %
[54.158.45.75:7000]0:1/1 78 % total: 96% 0.232KiB/s (avg: 0.024KiB/s)
progress: [35.173.233.153:7000]0:1/1 176% [10.0.2.238:7000]0:1/1 78 %
[54.158.45.75:7000]0:1/1 78 % total: 96% 0.000KiB/s (avg: 0.022KiB/s)
progress: [35.173.233.153:7000]0:1/1 176% [10.0.2.238:7000]0:1/1 78 %
[54.158.45.75:7000]0:1/1 78 % total: 96% 0.000KiB/s (avg: 0.021KiB/s)

sstableloader 的一些其他要求应予以考虑

  • 加载的 SSTable 必须与要加载到的 Cassandra 版本兼容。

  • 修复已加载到不同集群中的表不会修复源表。

  • Sstableloader 使用端口 7000 进行节点间通信。

  • 在恢复增量备份之前,运行 nodetool flush 以备份 memtable 中的任何数据。

使用 nodetool import

建议使用 nodetool import 命令将 SSTable 导入表,而不是使用已弃用的 nodetool refresh 命令。nodetool import 命令有一个选项可以从单独的目录加载新的 SSTable。

命令用法如下

nodetool [(-h <host> | --host <host>)] [(-p <port> | --port <port>)]
       [(-pp | --print-port)] [(-pw <password> | --password <password>)]
       [(-pwf <passwordFilePath> | --password-file <passwordFilePath>)]
       [(-u <username> | --username <username>)] import
       [(-c | --no-invalidate-caches)] [(-e | --extended-verify)]
       [(-l | --keep-level)] [(-q | --quick)] [(-r | --keep-repaired)]
       [(-t | --no-tokens)] [(-v | --no-verify)] [--] <keyspace> <table>
       <directory> ...

参数 keyspacetable 名称和 directory 是必需的。

支持以下选项

-c, --no-invalidate-caches
    Don't invalidate the row cache when importing

-e, --extended-verify
    Run an extended verify, verifying all values in the new SSTables

-h <host>, --host <host>
    Node hostname or ip address

-l, --keep-level
    Keep the level on the new SSTables

-p <port>, --port <port>
    Remote jmx agent port number

-pp, --print-port
    Operate in 4.0 mode with hosts disambiguated by port number

-pw <password>, --password <password>
    Remote jmx agent password

-pwf <passwordFilePath>, --password-file <passwordFilePath>
    Path to the JMX password file

-q, --quick
    Do a quick import without verifying SSTables, clearing row cache or
    checking in which data directory to put the file

-r, --keep-repaired
    Keep any repaired information from the SSTables

-t, --no-tokens
    Don't verify that all tokens in the new SSTable are owned by the
    current node

-u <username>, --username <username>
    Remote jmx agent username

-v, --no-verify
    Don't verify new SSTables

--
    This option can be used to separate command-line options from the
    list of argument, (useful when arguments might be mistaken for
    command-line options

由于 nodetool import 的命令行中指定了键空间和表,因此与 sstableloader 相比,没有相同的要求,即 SSTable 必须位于特定的目录路径中。使用 nodetool import 导入快照或增量备份时,SSTable 不需要复制到另一个目录。

从增量备份中导入数据

以下显示了使用 nodetool import 从增量备份中导入 SSTable 并还原表的步骤。

DROP table t;

表的增量备份不包含表的模式定义。如果模式定义没有作为单独的备份保存,则可以使用备份中的表的 schema.cql 来创建该表,如下所示

CREATE TABLE IF NOT EXISTS cqlkeyspace.t (
   id int PRIMARY KEY,
   k int,
   v text)
   WITH ID = d132e240-c217-11e9-bbee-19821dcea330
   AND bloom_filter_fp_chance = 0.01
   AND crc_check_chance = 1.0
   AND default_time_to_live = 0
   AND gc_grace_seconds = 864000
   AND min_index_interval = 128
   AND max_index_interval = 2048
   AND memtable_flush_period_in_ms = 0
   AND speculative_retry = '99p'
   AND additional_write_policy = '99p'
   AND comment = ''
   AND caching = { 'keys': 'ALL', 'rows_per_partition': 'NONE' }
   AND compaction = { 'max_threshold': '32', 'min_threshold': '4',
   'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy' }
   AND compression = { 'chunk_length_in_kb': '16', 'class':
   'org.apache.cassandra.io.compress.LZ4Compressor' }
   AND cdc = false
   AND extensions = {  }
;

最初,该表可以为空,但不需要为空。

SELECT * FROM t;
id | k | v
----+---+---

(0 rows)

运行nodetool import命令,提供 keyspace、表和备份目录。不要像使用sstableloader那样将表备份复制到另一个目录。

$ nodetool import -- cqlkeyspace t \
./cassandra/data/data/cqlkeyspace/t-d132e240c21711e9bbee19821dcea330/backups

SSTables 将被导入到表中。在 cqlsh 中运行一个查询以检查

SELECT * FROM t;
id | k | v
----+---+------
 1 | 1 | val1
 0 | 0 | val0

(2 rows)

从快照导入数据

使用nodetool import命令从快照导入 SSTables 类似于从增量备份导入 SSTables。这里展示了在删除表以演示恢复后,对表catalogkeyspace.journal的快照进行导入。

USE CATALOGKEYSPACE;
DROP TABLE journal;

使用catalog-ks快照用于journal表。检查快照中的文件,并注意schema.cql文件的存在。

$ ls -l
total 44
-rw-rw-r--. 1 ec2-user ec2-user   31 Aug 19 02:44 manifest.json
-rw-rw-r--. 3 ec2-user ec2-user   47 Aug 19 02:38 na-1-big-CompressionInfo.db
-rw-rw-r--. 3 ec2-user ec2-user   97 Aug 19 02:38 na-1-big-Data.db
-rw-rw-r--. 3 ec2-user ec2-user   10 Aug 19 02:38 na-1-big-Digest.crc32
-rw-rw-r--. 3 ec2-user ec2-user   16 Aug 19 02:38 na-1-big-Filter.db
-rw-rw-r--. 3 ec2-user ec2-user   16 Aug 19 02:38 na-1-big-Index.db
-rw-rw-r--. 3 ec2-user ec2-user 4687 Aug 19 02:38 na-1-big-Statistics.db
-rw-rw-r--. 3 ec2-user ec2-user   56 Aug 19 02:38 na-1-big-Summary.db
-rw-rw-r--. 3 ec2-user ec2-user   92 Aug 19 02:38 na-1-big-TOC.txt
-rw-rw-r--. 1 ec2-user ec2-user  814 Aug 19 02:44 schema.cql

schema.cql中复制 DDL 并运行在 cqlsh 中以创建catalogkeyspace.journal

CREATE TABLE IF NOT EXISTS catalogkeyspace.journal (
   id int PRIMARY KEY,
   name text,
   publisher text)
   WITH ID = 296a2d30-c22a-11e9-b135-0d927649052c
   AND bloom_filter_fp_chance = 0.01
   AND crc_check_chance = 1.0
   AND default_time_to_live = 0
   AND gc_grace_seconds = 864000
   AND min_index_interval = 128
   AND max_index_interval = 2048
   AND memtable_flush_period_in_ms = 0
   AND speculative_retry = '99p'
   AND additional_write_policy = '99p'
   AND comment = ''
   AND caching = { 'keys': 'ALL', 'rows_per_partition': 'NONE' }
   AND compaction = { 'min_threshold': '4', 'max_threshold':
   '32', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy' }
   AND compression = { 'chunk_length_in_kb': '16', 'class':
   'org.apache.cassandra.io.compress.LZ4Compressor' }
   AND cdc = false
   AND extensions = {  }
;

运行nodetool import命令以导入快照的 SSTables

$ nodetool import -- catalogkeyspace journal \
./cassandra/data/data/catalogkeyspace/journal-
296a2d30c22a11e9b1350d927649052c/snapshots/catalog-ks/

随后在journal表上运行 CQL 查询以检查导入的数据

SELECT * FROM journal;
id | name                      | publisher
----+---------------------------+------------------
 1 |        Couchbase Magazine |        Couchbase
 0 | Apache Cassandra Magazine | Apache Cassandra

(2 rows)

批量加载外部数据

我们讨论过的任何工具都不支持直接批量加载外部数据,这些工具包括sstableloadernodetool importsstableloadernodetool import要求数据以 SSTables 的形式存在。Apache Cassandra 支持一个 Java API,用于使用org.apache.cassandra.io.sstable.CQLSSTableWriter Java 类从输入数据生成 SSTables。随后,使用sstableloadernodetool import来批量加载 SSTables。

使用 CQLSSTableWriter Java API 生成 SSTables

要使用CQLSSTableWriter类生成 SSTables,需要以下内容

  • 一个生成 SSTable 的输出目录

  • SSTable 的模式

  • INSERT的准备语句

  • 一个分区器

输出目录必须在开始之前存在。创建一个目录(例如/sstables)并设置适当的权限。

$ sudo mkdir /sstables
$ sudo chmod  777 -R /sstables

要在 Java 应用程序中使用CQLSSTableWriter,为输出目录创建一个 Java 常量。

public static final String OUTPUT_DIR = "./sstables";

CQLSSTableWriter Java API 可以创建一个用户定义的类型。创建一个新的类型来存储int数据

String type = "CREATE TYPE CQLKeyspace.intType (a int, b int)";
// Define a String variable for the SSTable schema.
String schema = "CREATE TABLE CQLKeyspace.t ("
                 + "  id int PRIMARY KEY,"
                 + "  k int,"
                 + "  v1 text,"
                 + "  v2 intType,"
                 + ")";

为要使用的准备语句定义一个String变量

String insertStmt = "INSERT INTO CQLKeyspace.t (id, k, v1, v2) VALUES (?, ?, ?, ?)";

仅当不使用默认分区器Murmur3Partitioner时,才需要设置要使用的分区器。

所有这些变量或设置都由构建器类CQLSSTableWriter.Builder使用来创建一个CQLSSTableWriter对象。

为输出目录创建一个 File 对象。

File outputDir = new File(OUTPUT_DIR + File.separator + "CQLKeyspace" + File.separator + "t");

使用static方法CQLSSTableWriter.builder()获取一个CQLSSTableWriter.Builder对象。设置以下项目

  • 输出目录File对象

  • 用户定义的类型

  • SSTable 模式

  • 缓冲区大小

  • 准备语句

  • 可选地使用任何其他构建器选项

并调用build()方法以创建一个CQLSSTableWriter对象

CQLSSTableWriter writer = CQLSSTableWriter.builder()
                                             .inDirectory(outputDir)
                                             .withType(type)
                                             .forTable(schema)
                                             .withBufferSizeInMB(256)
                                             .using(insertStmt).build();

设置 SSTable 数据。如果使用了任何用户定义的类型,则为每种类型获取一个UserType对象

UserType userType = writer.getUDType("intType");

为生成的 SSTable 添加数据行

writer.addRow(0, 0, "val0", userType.newValue().setInt("a", 0).setInt("b", 0));
   writer.addRow(1, 1, "val1", userType.newValue().setInt("a", 1).setInt("b", 1));
   writer.addRow(2, 2, "val2", userType.newValue().setInt("a", 2).setInt("b", 2));

关闭写入器,完成 SSTable

writer.close();

CQLSSTableWriter类提供的其他公共方法是

方法 描述

addRow(java.util.List<java.lang.Object> values)

向写入器添加新行。返回一个 CQLSSTableWriter 对象。每个提供的 value 类型都应该与 value 所属的 CQL 列的类型相对应。java 类型和 CQL 类型之间的对应关系与 www.datastax.com/drivers/java/2.0/apidocs/com/datastax/driver/core/DataType.Name.html#asJavaC lass() 中记录的对应关系相同。

addRow(java.util.Map<java.lang.String,java.lang.Object> values)

向写入器添加新行。返回一个 CQLSSTableWriter 对象。这等同于其他 addRow 方法,但它接受一个 map,该 map 的键是添加的列的名称,而不是按创建此 SSTable 写入器时使用的插入语句的顺序获取值的列表。map 键中的列名必须为小写,除非声明的列名为区分大小写的引号标识符,在这种情况下,map 键必须使用列的精确大小写。values 参数是一个 map,它包含列名到列值的映射,表示要添加的新行。如果 map 中不包含列,则其值为 null。如果 map 包含与创建此 SSTable 写入器时使用的插入语句的列不对应的键,则忽略相应的 value。

addRow(java.lang.Object…​ values)

向写入器添加新行。返回一个 CQLSSTableWriter 对象。

CQLSSTableWriter.builder()

返回一个新的 CQLSSTableWriter 构建器。

close()

关闭写入器。

rawAddRow(java.nio.ByteBuffer…​ values)

向写入器添加新行,提供已序列化的二进制值。返回一个 CQLSSTableWriter 对象。行值必须与创建此 SSTable 写入器时使用的插入语句的绑定变量相对应。

rawAddRow(java.util.List<java.nio.ByteBuffer> values)

向写入器添加新行,提供已序列化的二进制值。返回一个 CQLSSTableWriter 对象。行值必须与创建此 SSTable 写入器时使用的插入语句的绑定变量相对应。

rawAddRow(java.util.Map<java.lang.String, java.nio.ByteBuffer> values)

向写入器添加新行,提供已序列化的二进制值。返回一个 CQLSSTableWriter 对象。行值必须与创建此 SSTable 写入器时使用的插入语句的绑定变量相对应。

getUDType(String dataType)

返回此 SSTable 写入器中使用的用户定义类型,可用于创建 UDTValue 实例。

CQLSSTableWriter.Builder类提供的其他公共方法是

方法 描述

inDirectory(String directory)

写入 SSTables 的目录。这是一个必填选项。要使用的目录应该已经存在并且可写。

inDirectory(File directory)

写入 SSTables 的目录。这是一个必填选项。要使用的目录应该已经存在并且可写。

forTable(String schema)

要创建 SSTable 的表的模式(CREATE TABLE 语句)。提供的 CREATE TABLE 语句必须使用完全限定的表名,即包含 keyspace 名的表名。这是一个必填选项。

withPartitioner(IPartitioner partitioner)

要使用的分区器。默认情况下,将使用 Murmur3Partitioner。如果这不是为其创建 SSTables 的集群使用的分区器,则需要提供正确的分区器。

using(String insert)

定义为给定 CQL 行添加值的顺序的 INSERT 或 UPDATE 语句。提供的 INSERT 语句必须使用完全限定的表名,即包含 keyspace 名的表名。此外,该语句必须使用绑定变量,因为这些变量将由生成的 SSTable 写入器绑定到值。这是一个必填选项。

withBufferSizeInMiB(int size)

要使用的缓冲区的大小。这定义了在作为新的 SSTable 写入之前要缓冲多少数据。这大致对应于创建的 SSTable 的数据大小。默认值为 128MB,对于 1GB 堆来说应该是合理的。如果在使用 SSTable 写入器时生成了 OutOfMemory 异常,则应该降低此值。

withBufferSizeInMB(int size)

已弃用,至少在下一个主要版本之前可用。请使用 withBufferSizeInMiB(int size),它与新名称的相同方法。

sorted()

创建一个期望排序输入的 CQLSSTableWriter。如果使用此选项,则生成的 SSTable 写入器将期望按 SSTable 排序顺序添加行(如果在行插入期间不是这种情况,则会抛出异常)。SSTable 排序顺序意味着添加行的方式使得它们的 partition key 符合分区器顺序。此选项仅应在可以按顺序提供行的情况下使用,这种情况很少见。但是,如果可以按顺序提供行,则使用此排序可能会更高效。如果使用此选项,则会忽略某些选项,例如 withBufferSizeInMB。

build()

构建一个 CQLSSTableWriter 对象。