natas_hw
/
cassandra
mirror of https://github.com/apache/cassandra
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'cassandra-5.0' into trunk 

* cassandra-5.0:
  Docs: Fix vsearch missing files
This commit is contained in:
Mick Semb Wever 2023-11-10 10:36:34 +01:00
parent 753f81d53a 709ae29fd8
commit c62de1b248
No known key found for this signature in database
GPG Key ID: E91335D77E3E87CB
38 changed files with 2471 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
doc/modules/cassandra/examples/CQL/comments-table.cql Normal file
View File

@ -0,0 +1,104 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
// tag::drop[]
DROP TABLE IF EXISTS cycling.comments;
// end::drop[]
/* Support fast retrieval of first record on each partition
and show upserts of timestamp type fields */
// tag::comments-table[]
CREATE TABLE IF NOT EXISTS cycling.comments (
record_id timeuuid,
id uuid,
commenter text,
comment text,
created_at timestamp,
PRIMARY KEY (id, created_at)
)
WITH CLUSTERING ORDER BY (created_at DESC);
// end::comments-table[]
DROP INDEX IF EXISTS cycling.fn_sparse;
// tag::fn_sparse[]
CREATE CUSTOM INDEX IF NOT EXISTS fn_sparse
ON cycling.comments (created_at)
USING 'org.apache.cassandra.index.sasi.SASIIndex'
WITH OPTIONS = { 'mode': 'SPARSE' };
// end::fn_sparse[]
// tag::insertall[]
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), e7ae5cf3-d358-4d99-b900-85902fda9bb0, '2017-02-14 12:43:20-0800', 'Raining too hard should have postponed', 'Alex');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), e7ae5cf3-d358-4d99-b900-85902fda9bb0, '2017-02-14 12:43:20.234-0800', 'Raining too hard should have postponed', 'Alex');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), e7ae5cf3-d358-4d99-b900-85902fda9bb0, '2017-03-21 13:11:09.999-0800', 'Second rest stop was out of water', 'Alex');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), e7ae5cf3-d358-4d99-b900-85902fda9bb0, '2017-04-01 06:33:02.16-0800', 'LATE RIDERS SHOULD NOT DELAY THE START', 'Alex');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), c7fceba0-c141-4207-9494-a29f9809de6f, totimestamp(now()), 'The gift certificate for winning was the best', 'Amy');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), c7fceba0-c141-4207-9494-a29f9809de6f, '2017-02-17 12:43:20.234+0400', 'Glad you ran the race in the rain', 'Amy');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), c7fceba0-c141-4207-9494-a29f9809de6f, '2017-03-22 5:16:59.001+0400', 'Great snacks at all reststops', 'Amy');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), c7fceba0-c141-4207-9494-a29f9809de6f, '2017-04-01 17:43:08.030+0400', 'Last climb was a killer', 'Amy');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 8566eb59-07df-43b1-a21b-666a3c08c08a, totimestamp(now()), 'Fastest womens time ever way to go amy!', 'Maryanne');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 8566eb59-07df-43b1-a21b-666a3c08c08a, '2017-02-13 11:20:17.020-0600', 'Great race on a crappy day', 'Maryanne');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 8566eb59-07df-43b1-a21b-666a3c08c08a, '2017-03-20 15:45:10.101-0600', 'Saggers really rocked it', 'Maryanne');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 8566eb59-07df-43b1-a21b-666a3c08c08a, '2017-04-14 05:16:52.009-0600', 'Not bad for a flatlander', 'Maryanne');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), fb372533-eb95-4bb4-8685-6ef61e994caa, totimestamp(now()), 'Great course', 'Michael');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), fb372533-eb95-4bb4-8685-6ef61e994caa, '2017-02-15 18:22:11-0800', 'Some entries complain a lot', 'Michael');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), fb372533-eb95-4bb4-8685-6ef61e994caa, '2017-03-16 19:43:01.030-0800', 'Getting read for the race', 'Michael');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), fb372533-eb95-4bb4-8685-6ef61e994caa, '2017-03-22 1:19:44.060-0800', 'Awesome race glad you held it anyway', 'Michael');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), fb372533-eb95-4bb4-8685-6ef61e994caa, '2017-04-07 11:21:14.001-0800', 'Thanks for waiting for me!', 'Michael');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 9011d3be-d35c-4a8d-83f7-a3c543789ee7, totimestamp(now()), 'Can''t wait for the next race', 'Katarzyna');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 9011d3be-d35c-4a8d-83f7-a3c543789ee7, '2017-01-01 11:20:17.020-0600', 'Gearing up for the seaon', 'Katarzyna');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 5b6962dd-3f90-4c93-8f61-eabfa4a803e2, totimestamp(now()), 'Thanks for all your hard work', 'Marianne');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 220844bf-4860-49d6-9a4b-6b5d3a79cbfb, totimestamp(now()), 'A for effort!', 'Paolo');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), c4b65263-fe58-4846-83e8-f0e1c13d518f, totimestamp(now()), 'Closing ceremony was a little lame', 'Rossella');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 38ab64b6-26cc-4de9-ab28-c257cf011659, totimestamp(now()), 'Next time guys!', 'Marcia');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 38ab64b6-26cc-4de9-ab28-c257cf011659, '2017-02-11 22:09:56+0800', 'First race was amazing, can''t wait for more', 'Marcia');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47, totimestamp(now()), 'So many great races thanks y''all', 'Steven');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47, '2017-02-02 09:49:00.02+0800', 'Best of luck everybody I can''t make it', 'Steven');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47, '2017-04-05 12:01:00.003', 'Bike damaged in transit bummer', 'Steven');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), e7cd5752-bc0d-4157-a80f-7523add8dbcd, totimestamp(now()), 'Go team, you rocked it', 'Anna');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 6d5f1663-89c0-45fc-8cfd-60a373b01622, totimestamp(now()), 'Next year the tour of california!', 'Melissa');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 95addc4c-459e-4ed7-b4b5-472f19a67995, totimestamp(now()), 'Next year for sure!', 'Vera');
INSERT INTO cycling.comments (record_id, id, created_at, comment, commenter) VALUES (now(), 95addc4c-459e-4ed7-b4b5-472f19a67995, '2017-02-13 11:40:16.123-0600', 'I can do without the rain@@@@', 'Vera');
// end::insertall[]
CAPTURE 'select_from_comments.results';
// tag::select[]
SELECT *
FROM cycling.comments
WHERE created_at < '2017-02-13 11:40:16.123';
// end::select[]
CAPTURE OFF;
// tag::alt[]
ALTER TABLE cycling.comments
WITH compression = {
'sstable_compression' : 'DeflateCompressor',
'chunk_length_kb' : 64
};
// end::alt[]
// tag::cache[]
ALTER TABLE cycling.comments
WITH caching = {
'keys' : 'NONE',
'rows_per_partition' : 10
};
// end::cache[]
// tag::nocompact[]
ALTER TABLE cycling.comments
WITH COMPACTION = {
'class' : 'SizeTieredCompactionStrategy',
'enabled' : 'false'
};
// end::nocompact[]
// tag::compaction[]
ALTER TABLE cycling.comments
WITH COMPACTION = {
'class' : 'SizeTieredCompactionStrategy',
'enabled' : 'true'
};
// end::compaction[]

84
doc/modules/cassandra/examples/CQL/country_flag-table.cql Normal file
View File

@ -0,0 +1,84 @@
// CREATE TABLE WITH STATIC COLUMN, example uses an integer to identify flag, but it could be a blob
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
DROP TABLE IF EXISTS cycling.country_flag;
// tag::staticColumn[]
CREATE TABLE IF NOT EXISTS cycling.country_flag (
country text,
cyclist_name text,
flag int STATIC,
PRIMARY KEY (country, cyclist_name)
);
// end::staticColumn[]
// tag::insert[]
INSERT INTO cycling.country_flag (
country, cyclist_name, flag
) VALUES (
'Belgium', 'Jacques', 1
);
INSERT INTO cycling.country_flag (
country, cyclist_name
) VALUES (
'Belgium', 'Andre'
);
INSERT INTO cycling.country_flag (
country, cyclist_name, flag
) VALUES (
'France', 'Andre', 2
);
INSERT INTO cycling.country_flag (
country, cyclist_name, flag
) VALUES (
'France', 'George', 3
);
// end::insert[]
CAPTURE 'select_initial_from_country_flag.results';
// Query to view inserted data
// tag::select[]
SELECT *
FROM cycling.country_flag;
// end::select[]
CAPTURE OFF;
// Truncate data without dropping the table
// tag::truncate[]
TRUNCATE cycling.country_flag;
// end::truncate[]
// Query again to view data truncated from table
// tag::emptytable[]
SELECT *
FROM cycling.country_flag;
// end::emptytable[]
// Insert data again
INSERT INTO cycling.country_flag (
country, cyclist_name, flag
) VALUES (
'Belgium', 'Jacques', 1
);
INSERT INTO cycling.country_flag (
country, cyclist_name
) VALUES (
'Belgium', 'Andre'
);
INSERT INTO cycling.country_flag (
country, cyclist_name, flag
) VALUES (
'France', 'Andre', 2
);
INSERT INTO cycling.country_flag (
country, cyclist_name, flag
) VALUES (
'France', 'George', 3
);

84
doc/modules/cassandra/examples/CQL/cyclist_base-table.cql Normal file
View File

@ -0,0 +1,84 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
DROP TABLE IF EXISTS cycling.cyclist_base;
// tag::cyclist_base[]
CREATE TABLE IF NOT EXISTS cycling.cyclist_base (
cid UUID PRIMARY KEY,
name text,
age int,
birthday date,
country text
);
// end::cyclist_base[]
// tag::data[]
INSERT INTO cycling.cyclist_base (
cid,name,age,birthday,country
) VALUES (
e7ae5cf3-d358-4d99-b900-85902fda9bb0,'Alex FRAME', 22, '1993-06-18', 'New Zealand'
);
INSERT INTO cycling.cyclist_base (
cid,name,age,birthday,country
) VALUES (
220844bf-4860-49d6-9a4b-6b5d3a79cbfb,'Paolo TIRALONGO', 38, '1977-07-08', 'Italy'
);
INSERT INTO cycling.cyclist_base (
cid,name,age,birthday,country
) VALUES (
6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47,'Steven KRUIKSWIJK', 28, '1987-06-07', 'Netherlands'
);
INSERT INTO cycling.cyclist_base (
cid,name,age,birthday,country
) VALUES (
ffdfa2a7-5fc6-49a7-bfdc-3fcdcfdd7156,'Pascal EENKHOORN', 18, '1997-02-08', 'Netherlands'
);
INSERT INTO cycling.cyclist_base (
cid,name,age,birthday,country
) VALUES (
18f471bf-f631-4bc4-a9a2-d6f6cf5ea503,'Bram WELTEN', 18, '1997-03-29', 'Netherlands'
);
INSERT INTO cycling.cyclist_base (
cid,name,age,birthday,country
) VALUES (
15a116fc-b833-4da6-ab9a-4a7775752836,'Adrien COSTA', 18, '1997-08-19', 'United States'
);
INSERT INTO cycling.cyclist_base (
cid,name,age,birthday,country
) VALUES (
862cc51f-00a1-4d5a-976b-a359cab7300e,'Joakim BUKDAL', 20, '1994-09-04', 'Denmark'
);
INSERT INTO cycling.cyclist_base (
cid,name,age,birthday,country
) VALUES (
c9c9c484-5e4a-4542-8203-8d047a01b8a8,'Cristian EGIDIO', 27, '1987-09-04', 'Brazil'
);
// end::data[]
CAPTURE 'select_all_from_cyclist_base.results';
SELECT *
FROM cycling.cyclist_base;
CAPTURE OFF;
// tag::alt[]
ALTER TABLE cycling.cyclist_base
WITH comment = 'basic cyclist information';
// end::alt[]
// tag::specr[]
ALTER TABLE cycling.cyclist_base
WITH speculative_retry = '95percentile';
// end::specr[]
// tag::milli[]
ALTER TABLE cycling.cyclist_base
WITH speculative_retry = '10ms';
// end::milli[]

118
doc/modules/cassandra/examples/CQL/cyclist_category-table.cql Normal file
View File

@ -0,0 +1,118 @@
// Find cyclists that fit a particular category
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
// CREATE TABLE CLUSTERING ORDER, PRIMARY KEY: PARTITION KEY + 1 CLUSTERING COLUMN, SIMPLE WHERE QUERY
DROP TABLE IF EXISTS cycling.cyclist_category;
// tag::use_and_cpartitionkey[]
USE cycling;
CREATE TABLE IF NOT EXISTS cyclist_category (
category text,
points int,
id UUID,
lastname text,
PRIMARY KEY (category, points)
)
WITH CLUSTERING ORDER BY (points DESC);
// end::use_and_cpartitionkey[]
DROP TABLE IF EXISTS cycling.cyclist_category;
// tag::cpartitionkey[]
CREATE TABLE IF NOT EXISTS cycling.cyclist_category (
category text,
points int,
id UUID,
lastname text,
PRIMARY KEY (category, points)
)
WITH CLUSTERING ORDER BY (points DESC);
// end::cpartitionkey[]
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('GC',1269,220844bf-4860-49d6-9a4b-6b5d3a79cbfb,'TIRALONGO');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('One-day-races',367,220844bf-4860-49d6-9a4b-6b5d3a79cbfb,'TIRALONGO');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('Time-trial',182,220844bf-4860-49d6-9a4b-6b5d3a79cbfb,'TIRALONGO');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('Sprint',0,220844bf-4860-49d6-9a4b-6b5d3a79cbfb,'TIRALONGO');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('GC',1324,6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47,'KRUIJSWIJK');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('One-day-races',198,6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47,'KRUIJSWIJK');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('Sprint',39,6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47,'KRUIJSWIJK');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('Time-trial',3,6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47,'KRUIJSWIJK');
// tag::rows[]
RESTRICT ROWS ON cycling.cyclist_category USING category;
// end::rows[]
CAPTURE 'select_all_from_cyclist_category_order_by_descending_points.results';
// tag::select_compound_primary_key[]
SELECT *
FROM cycling.cyclist_category
WHERE category = 'Time-trial'
ORDER BY points DESC;
// end::select_compound_primary_key[]
CAPTURE OFF;
// Add JSON rows
// tag::insert_SUTHERLAND[]
INSERT INTO cycling.cyclist_category JSON '{
"category" : "GC",
"points" : 780,
"id" : "829aa84a-4bba-411f-a4fb-38167a987cda",
"lastname" : "SUTHERLAND"
}';
// end::insert_SUTHERLAND[]
// tag::clear_lastname[]
INSERT INTO cycling.cyclist_category JSON '{
"category" : "Sprint",
"points" : 780,
"id" : "829aa84a-4bba-411f-a4fb-38167a987cda"
}';
// end::clear_lastname[]
// tag::unset[]
INSERT INTO cycling.cyclist_category JSON '{
"category" : "Sprint",
"points" : 780,
"id" : "829aa84a-4bba-411f-a4fb-38167a987cda"
}'
DEFAULT UNSET;
// end::unset[]
// tag::set_points[]
INSERT INTO cycling.cyclist_category JSON '{
"category" : "Sprint",
"points" : 700,
"id" : "829aa84a-4bba-411f-a4fb-38167a987cda"
}';
// end::set_points[]
CAPTURE 'select_all_from_cyclist_category.results';
// tag::select_all_rows[]
SELECT *
FROM cycling.cyclist_category;
// end::select_all_rows[]
CAPTURE OFF;
// tag::copy[]
COPY cycling.cyclist_category
FROM 'cyclist_category.csv'
WITH DELIMITER = '|'
AND HEADER = TRUE;
// end::copy[]
// Truncate table
TRUNCATE TABLE cycling.cyclist_category;
// Re-insert data
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('GC',1269,220844bf-4860-49d6-9a4b-6b5d3a79cbfb,'TIRALONGO');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('One-day-races',367,220844bf-4860-49d6-9a4b-6b5d3a79cbfb,'TIRALONGO');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('Time-trial',182,220844bf-4860-49d6-9a4b-6b5d3a79cbfb,'TIRALONGO');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('Sprint',0,220844bf-4860-49d6-9a4b-6b5d3a79cbfb,'TIRALONGO');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('GC',1324,6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47,'KRUIJSWIJK');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('One-day-races',198,6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47,'KRUIJSWIJK');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('Sprint',39,6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47,'KRUIJSWIJK');
INSERT INTO cycling.cyclist_category (category, points, id, lastname) VALUES ('Time-trial',3,6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47,'KRUIJSWIJK');

35
doc/modules/cassandra/examples/CQL/cyclist_emails-table.cql Normal file
View File

@ -0,0 +1,35 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
DROP TABLE IF EXISTS cycling.cyclist_emails;
// Create a table with a known table id
// tag::ID[]
CREATE TABLE IF NOT EXISTS cycling.cyclist_emails (
userid text PRIMARY KEY,
id UUID,
emails set<text>
)
WITH ID = '1bb7516e-b140-11e8-96f8-529269fb1459';
// end::ID[]
// Drop table
DROP TABLE IF EXISTS cycling.cyclist_emails;
// Create table again with a known table id
// tag::recreateID[]
CREATE TABLE IF NOT EXISTS cycling.cyclist_emails (
userid text PRIMARY KEY,
id UUID,
emails set<text>
)
WITH ID = '1bb7516e-b140-11e8-96f8-529269fb1459';
// end::recreateID[]
// Retrieve the table id
// tag::select_id_from_system_schema[]
SELECT id
FROM system_schema.tables
WHERE keyspace_name = 'cycling'
AND table_name = 'cyclist_emails';
// end::select_id_from_system_schema[]

216
doc/modules/cassandra/examples/CQL/cyclist_expenses-table.cql Normal file
View File

@ -0,0 +1,216 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
DROP TABLE IF EXISTS cycling.cyclist_expenses;
// tag::create_table[]
CREATE TABLE IF NOT EXISTS cycling.cyclist_expenses (
cyclist_name text,
balance float STATIC,
expense_id int,
amount float,
description text,
paid boolean,
PRIMARY KEY (cyclist_name, expense_id)
);
// end::create_table[]
// tag::batch_Vera[]
BEGIN BATCH
INSERT INTO cycling.cyclist_expenses (
cyclist_name, balance
) VALUES (
'Vera ADRIAN', 0
) IF NOT EXISTS;
INSERT INTO cycling.cyclist_expenses (
cyclist_name, expense_id, amount, description, paid
) VALUES (
'Vera ADRIAN', 1, 7.95, 'Breakfast', false
);
APPLY BATCH;
// end::batch_Vera[]
CAPTURE 'select_initial_from_cyclist_expenses.results';
// tag::select_initial[]
SELECT *
FROM cycling.cyclist_expenses;
// end::select_initial[]
CAPTURE OFF;
// tag::update_Vera[]
UPDATE cycling.cyclist_expenses
SET balance = -7.95
WHERE cyclist_name = 'Vera ADRIAN'
IF balance = 0;
// end::update_Vera[]
CAPTURE 'select_after_update_from_cyclist_expenses.results';
SELECT *
FROM cycling.cyclist_expenses;
CAPTURE OFF;
// tag::batch_food[]
BEGIN BATCH
INSERT INTO cycling.cyclist_expenses (
cyclist_name, expense_id, amount, description, paid
) VALUES (
'Vera ADRIAN', 2, 13.44, 'Lunch', true
);
INSERT INTO cycling.cyclist_expenses (
cyclist_name, expense_id, amount, description, paid
) VALUES (
'Vera ADRIAN', 3, 25.00, 'Dinner', false
);
UPDATE cycling.cyclist_expenses
SET balance = -32.95
WHERE cyclist_name = 'Vera ADRIAN'
IF balance = -7.95;
APPLY BATCH;
// end::batch_food[]
CAPTURE 'select_after_batch_food_from_cyclist_expenses.results';
SELECT *
FROM cycling.cyclist_expenses;
CAPTURE OFF;
// tag::batch_paid[]
BEGIN BATCH
UPDATE cycling.cyclist_expenses
SET balance = 0
WHERE cyclist_name = 'Vera ADRIAN'
IF balance = -32.95;
UPDATE cycling.cyclist_expenses
SET paid = true
WHERE cyclist_name = 'Vera ADRIAN'
AND expense_id = 1 IF paid = false;
UPDATE cycling.cyclist_expenses
SET paid = true
WHERE cyclist_name = 'Vera ADRIAN'
AND expense_id = 3
IF paid = false;
APPLY BATCH;
// end::batch_paid[]
CAPTURE 'select_after_batch_paid_from_cyclist_expenses.results';
SELECT *
FROM cycling.cyclist_expenses;
CAPTURE OFF;
// tag::batch_multiple_partitions[]
BEGIN BATCH
INSERT INTO cycling.cyclist_expenses (
cyclist_name, expense_id, amount, description, paid
) VALUES (
'John SMITH', 3, 15.00, 'Lunch', false
);
INSERT INTO cycling.cyclist_name (
id, lastname, firstname
) VALUES (
6ab09bec-e68e-48d9-a5f8-97e6fb4c9b12, 'SMITH', 'John'
);
APPLY BATCH;
// end::batch_multiple_partitions[]
DELETE FROM cycling.cyclist_name
WHERE id = 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b12;
TRUNCATE TABLE cycling.cyclist_expenses;
// tag::batch[]
BEGIN BATCH USING TIMESTAMP 1481124356754405
INSERT INTO cycling.cyclist_expenses (
cyclist_name, expense_id, amount, description, paid
) VALUES (
'Vera ADRIAN', 2, 13.44, 'Lunch', true
);
INSERT INTO cycling.cyclist_expenses (
cyclist_name, expense_id, amount, description, paid
) VALUES (
'Vera ADRIAN', 3, 25.00, 'Dinner', true
);
APPLY BATCH;
// end::batch[]
// tag::con[]
BEGIN BATCH
INSERT INTO cycling.cyclist_expenses (
cyclist_name, expense_id
) VALUES (
'Joe WALLS', 1
)
IF NOT EXISTS;
INSERT INTO cycling.cyclist_expenses (
cyclist_name, expense_id, amount, description, paid
) VALUES (
'Joe WALLS', 1, 8, 'burrito', false
);
APPLY BATCH;
// end::con[]
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',1,50,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',2,50,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',3,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',4,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Alex FRAME',5,40,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Alex FRAME',6,40,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Steven KRUIKSWIJK',7,20,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Steven KRUIKSWIJK',8,39,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Marianne VOS',9,20,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Marianne VOS',10,20,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',11,10,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',12,10,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',13,50,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',14,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',15,35,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',16,20,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',17,70,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',18,10,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',19,50,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',20,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',21,35,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',22,20,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Anna VAN DER BREGGEN',23,70,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',24,10,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',25,11,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',26,12,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',27,13,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',28,14,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',29,15,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',30,16,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',31,17,'dinner');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Paolo TIRALONGO',32,18,'breakfast');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Steven KRUIKSWIJK',33,3,'coffee');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Steven KRUIKSWIJK',34,3,'coffee');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Steven KRUIKSWIJK',35,3,'coffee');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Steven KRUIKSWIJK',36,3,'coffee');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Steven KRUIKSWIJK',37,3,'coffee');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Steven KRUIKSWIJK',38,3,'coffee');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Steven KRUIKSWIJK',39,3,'coffee');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',40,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',41,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',42,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',43,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',44,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',45,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',46,25,'lunch');
insert into cycling.cyclist_expenses (cyclist_name,expense_id,amount,description) values ('Michael MATTHEWS',47,25,'lunch');

77
doc/modules/cassandra/examples/CQL/cyclist_id-table.cql Normal file
View File

@ -0,0 +1,77 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
DROP TABLE IF EXISTS cycling.cyclist_id;
// Find a cyclist's id given lastname and firstname
// Another CREATE TABLE using COMPOSITE PARTITION KEY
// INDEX ALSO GOOD FOR THIS TABLE
// tag::comp_pk[]
CREATE TABLE IF NOT EXISTS cycling.cyclist_id (
lastname text,
firstname text,
age int,
id UUID,
PRIMARY KEY ((lastname, firstname), age)
);
// end::comp_pk[]
// tag::altercdc[]
ALTER TABLE cycling.cyclist_id
WITH CDC = false;
// end::altercdc[]
INSERT INTO cycling.cyclist_id (
lastname, firstname, age, id
) VALUES (
'EENKHOORN', 'Pascal', 18, ffdfa2a7-5fc6-49a7-bfdc-3fcdcfdd7156
);
INSERT INTO cycling.cyclist_id (
lastname, firstname, age, id
) VALUES (
'WELTEN', 'Bram', 18, 18f471bf-f631-4bc4-a9a2-d6f6cf5ea503
);
INSERT INTO cycling.cyclist_id (
lastname, firstname, age, id
) VALUES (
'COSTA', 'Adrien', 17, 15a116fc-b833-4da6-ab9a-4a7775752836
);
// tag::resetid[]
UPDATE cycling.cyclist_id
SET id = UUID()
WHERE lastname = 'WELTEN'
AND firstname = 'Bram'
AND age = 18
IF EXISTS;
// end::resetid[]
// tag::ifid[]
UPDATE cycling.cyclist_id
SET id = UUID()
WHERE lastname = 'WELTEN'
AND firstname = 'Bram'
AND age = 18
IF id = 18f471bf-f631-4bc4-a9a2-d6f6cf5ea503;
// end::ifid[]
// tag::ifnull[]
UPDATE cycling.cyclist_id
SET id = UUID()
WHERE lastname = 'Smith'
AND firstname = 'Joe'
AND age = 22
IF id = NULL;
// end::ifnull[]
// tag::select_with_in_and_equals[]
SELECT *
FROM cycling.cyclist_id
WHERE lastname = 'EENKHOORN'
AND firstname = 'Pascal'
AND age IN (17, 18);
// end::select_with_in_and_equals[]

486
doc/modules/cassandra/examples/CQL/cyclist_name-table.cql Normal file
View File

@ -0,0 +1,486 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
// tag::droptble[]
DROP TABLE IF EXISTS cycling.cyclist_name;
// end::droptble[]
// tag::pk_at_start[]
USE cycling;
CREATE TABLE cyclist_name (
id UUID PRIMARY KEY,
lastname text,
firstname text
);
// end::pk_at_start[]
DROP TABLE IF EXISTS cycling.cyclist_name;
// tag::pk_at_end[]
USE cycling;
CREATE TABLE cycling.cyclist_name (
id UUID,
lastname text,
firstname text,
PRIMARY KEY (id)
);
// end::pk_at_end[]
DROP TABLE IF EXISTS cycling.cyclist_name;
// tag::keyspace_included[]
CREATE TABLE cycling.cyclist_name (
id UUID PRIMARY KEY,
lastname text,
firstname text
);
// end::keyspace_included[]
DROP TABLE IF EXISTS cycling.cyclist_name;
// Create a table with a simple partition key
// tag::simple[]
CREATE TABLE IF NOT EXISTS cycling.cyclist_name (
id UUID PRIMARY KEY,
lastname text,
firstname text
);
// end::simple[]
// tag::uuid[]
INSERT INTO cycling.cyclist_name (
id
) VALUES (
uuid()
);
// end::uuid[]
// tag::batch[]
BEGIN BATCH
INSERT INTO cycling.cyclist_name (
id, lastname, firstname
) VALUES (
6d5f1663-89c0-45fc-8cfd-60a373b01622,'HOSKINS', 'Melissa'
);
INSERT INTO cycling.cyclist_name (
id, lastname, firstname
) VALUES (
38ab64b6-26cc-4de9-ab28-c257cf011659,'FERNANDES', 'Marcia'
);
INSERT INTO cycling.cyclist_name (
id, lastname, firstname
) VALUES (
9011d3be-d35c-4a8d-83f7-a3c543789ee7,'NIEWIADOMA', 'Katarzyna'
);
INSERT INTO cycling.cyclist_name (
id, lastname, firstname
) VALUES (
95addc4c-459e-4ed7-b4b5-472f19a67995,'ADRIAN', 'Vera'
);
APPLY BATCH;
// end::batch[]
TRUNCATE cycling.cyclist_name;
// Insert data with TTL and timestamp
// tag::insertstampttl[]
INSERT INTO cycling.cyclist_name (
id, lastname, firstname
) VALUES (
6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47, 'KRUIKSWIJK', 'Steven'
)
USING TTL 86400
AND TIMESTAMP 123456789;
// end::insertstampttl[]
// tag::insertifnotexists[]
INSERT INTO cycling.cyclist_name (
id, lastname, firstname
) VALUES (
c4b65263-fe58-4846-83e8-f0e1c13d518f, 'RATTO', 'Rissella'
)
IF NOT EXISTS;
// end::insertifnotexists[]
DROP INDEX IF EXISTS fn_prefix;
// tag::fn_prefix[]
CREATE CUSTOM INDEX IF NOT EXISTS fn_prefix
ON cycling.cyclist_name (firstname)
USING 'org.apache.cassandra.index.sasi.SASIIndex';
// end::fn_prefix[]
TRUNCATE cycling.cyclist_name;
// Insert 6 rows of cyclists
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (5b6962dd-3f90-4c93-8f61-eabfa4a803e2, 'VOS','Marianne');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (e7cd5752-bc0d-4157-a80f-7523add8dbcd, 'VAN DER BREGGEN','Anna');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (e7ae5cf3-d358-4d99-b900-85902fda9bb0, 'FRAME','Alex');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (220844bf-4860-49d6-9a4b-6b5d3a79cbfb, 'TIRALONGO','Paolo');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47, 'KRUIKSWIJK','Steven');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (fb372533-eb95-4bb4-8685-6ef61e994caa, 'MATTHEWS', 'Michael');
// View output
CAPTURE 'select_all_from_cycling_initial.results';
// tag::select_initial[]
SELECT *
FROM cycling.cyclist_name;
// end::select_initial[]
CAPTURE OFF;
CAPTURE 'select_marianne_from_cyclist_name.results';
// tag::select_Marianne[]
SELECT *
FROM cycling.cyclist_name
WHERE firstname = 'Marianne';
// end::select_Marianne[]
CAPTURE OFF;
CAPTURE 'select_like_M_from_cyclist_name.results';
// tag::select_like_M_start[]
SELECT *
FROM cycling.cyclist_name
WHERE firstname LIKE 'M%';
// end::select_like_M_start[]
CAPTURE OFF;
// tag::no_match_upper[]
SELECT * FROM cycling.cyclist_name WHERE firstname = 'MARIANNE';
// end::no_match_upper[]
// tag::no_match_lower[]
SELECT * FROM cycling.cyclist_name WHERE firstname LIKE 'm%';
// end::no_match_lower[]
// tag::no_match_equality[]
SELECT * FROM cycling.cyclist_name WHERE firstname = 'M%';
SELECT * FROM cycling.cyclist_name WHERE firstname = '%M';
SELECT * FROM cycling.cyclist_name WHERE firstname = '%M%';
SELECT * FROM cycling.cyclist_name WHERE firstname = 'm%';
// end::no_match_equality[]
DROP INDEX IF EXISTS fn_contains;
// tag::fn_contains[]
CREATE CUSTOM INDEX IF NOT EXISTS fn_contains
ON cycling.cyclist_name (firstname)
USING 'org.apache.cassandra.index.sasi.SASIIndex'
WITH OPTIONS = { 'mode': 'CONTAINS' };
// end::fn_contains[]
// These examples generate an error if they are run before the fn_contains index
// is created
// tag::like[]
SELECT * FROM cycling.cyclist_name WHERE firstname LIKE '%m%';
SELECT * FROM cycling.cyclist_name WHERE firstname LIKE '%m%' ALLOW FILTERING;
SELECT * FROM cycling.cyclist_name WHERE firstname LIKE '%M%';
// end::like[]
CAPTURE 'select_marianne_allow_filtering_from_cyclist_name.results';
// tag::select_marianne_allow_filtering[]
SELECT *
FROM cycling.cyclist_name
WHERE firstname = 'Marianne'
ALLOW FILTERING;
// end::select_marianne_allow_filtering[]
CAPTURE OFF;
CAPTURE 'select_like_M_partial_from_cyclist_name.results';
// tag::select_like_M_partial[]
SELECT *
FROM cycling.cyclist_name
WHERE firstname LIKE '%M%';
// end::select_like_M_partial[]
CAPTURE OFF;
CAPTURE 'select_arianne_from_cyclist_name.results';
// tag::select_arianne[]
SELECT *
FROM cycling.cyclist_name
WHERE firstname LIKE '%arianne';
// end::select_arianne[]
CAPTURE OFF;
CAPTURE 'select_arian_from_cyclist_name.results';
// tag::select_arian_name[]
SELECT *
FROM cycling.cyclist_name
WHERE firstname LIKE '%arian%';
// end::select_arian_name[]
CAPTURE OFF;
CAPTURE 'select_mar_from_cyclist_name.results';
// tag::select_greater_Mar[]
SELECT *
FROM cycling.cyclist_name
WHERE firstname > 'Mar'
ALLOW FILTERING;
// end::select_greater_Mar[]
CAPTURE OFF;
// These examples do not return a match when they are run before the
// fn_suffix_allcase index is created
// tag::no_match_partial[]
SELECT * FROM cycling.cyclist_name WHERE firstname = 'MariAnne' ALLOW FILTERING;
SELECT * FROM cycling.cyclist_name WHERE firstname LIKE '%m%';
SELECT * FROM cycling.cyclist_name WHERE firstname LIKE '%M';
SELECT * FROM cycling.cyclist_name WHERE firstname LIKE 'm%';
// end::no_match_partial[]
DROP INDEX IF EXISTS fn_suffix_allcase;
// tag::fn_suffix_allcase[]
CREATE CUSTOM INDEX IF NOT EXISTS fn_suffix_allcase
ON cycling.cyclist_name (firstname)
USING 'org.apache.cassandra.index.sasi.SASIIndex'
WITH OPTIONS = {
'mode': 'CONTAINS',
'analyzer_class': 'org.apache.cassandra.index.sasi.analyzer.NonTokenizingAnalyzer',
'case_sensitive': 'false'
};
// end::fn_suffix_allcase[]
CAPTURE 'select_like_m_lower_from_cyclist_name.results';
// tag::select_like_m_lower[]
SELECT *
FROM cycling.cyclist_name
WHERE firstname LIKE '%m%';
// end::select_like_m_lower[]
CAPTURE OFF;
// tag::alter[]
ALTER TABLE cycling.cyclist_name
ADD age int;
UPDATE cycling.cyclist_name
SET age = 23
WHERE id = 5b6962dd-3f90-4c93-8f61-eabfa4a803e2;
INSERT INTO cycling.cyclist_name (
id, age, firstname, lastname
) VALUES (
8566eb59-07df-43b1-a21b-666a3c08c08a, 18, 'Marianne', 'DAAE'
);
// end::alter[]
CAPTURE 'select_name_and_age_filter_from_cyclist_name.results';
// tag::select_name_and_age_filter[]
SELECT *
FROM cycling.cyclist_name
WHERE firstname = 'Marianne'
AND age > 20
ALLOW FILTERING;
// end::select_name_and_age_filter[]
CAPTURE OFF;
// Undo the changes in the alter section
DELETE FROM cycling.cyclist_name
WHERE id = 8566eb59-07df-43b1-a21b-666a3c08c08a;
ALTER TABLE cycling.cyclist_name
DROP age;
// Delete data in specified columns from a row, changes cyclist Alex Frame to null in name columns
// tag::deletecolumndata[]
DELETE firstname, lastname
FROM cycling.cyclist_name
WHERE id = e7ae5cf3-d358-4d99-b900-85902fda9bb0;
// end::deletecolumndata[]
// View output
CAPTURE 'cyclist_name_delete_firstname_and_lastname.results';
SELECT *
FROM cycling.cyclist_name;
CAPTURE OFF;
// Delete an entire row, deletes cyclist Alex Frame altogether
CAPTURE 'cyclist_name_delete_applied_true.results';
// tag::deleteentirerow[]
DELETE FROM cycling.cyclist_name
WHERE id = e7ae5cf3-d358-4d99-b900-85902fda9bb0
IF EXISTS;
// end::deleteentirerow[]
CAPTURE OFF;
// View output
CAPTURE 'cyclist_name_delete_entire_row.results';
SELECT *
FROM cycling.cyclist_name;
CAPTURE OFF;
// Delete a row based on a static column condition, attempts to delete cyclist Michael Matthews but lastname does not match
CAPTURE 'cyclist_name_delete_condition.results';
// tag::deletecondition[]
DELETE FROM cycling.cyclist_name
WHERE id = fb372533-eb95-4bb4-8685-6ef61e994caa
IF firstname = 'Michael'
AND lastname = 'Smith';
// end::deletecondition[]
CAPTURE OFF;
// View output
SELECT *
FROM cycling.cyclist_name;
// Delete a row with a WHERE clause, deletes cyclist Steven Kruikswijk
// tag::deleterowhere[]
DELETE FROM cycling.cyclist_name
WHERE id = 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47;
// end::deleterowhere[]
// View output
CAPTURE 'cyclist_name_delete_row_where.results';
SELECT *
FROM cycling.cyclist_name;
CAPTURE OFF;
// Delete rows using an IN clause on a primary key, deletes cyclists Marianne and Paolo
// tag::deletein[]
DELETE FROM cycling.cyclist_name
WHERE id IN (
5b6962dd-3f90-4c93-8f61-eabfa4a803e2, 220844bf-4860-49d6-9a4b-6b5d3a79cbfb
);
// end::deletein[]
// View output
CAPTURE 'cyclist_name_delete_in.results';
SELECT *
FROM cycling.cyclist_name;
CAPTURE OFF;
// tag::delete_lastname[]
DELETE lastname
FROM cycling.cyclist_name
WHERE id = c7fceba0-c141-4207-9494-a29f9809de6f;
// end::delete_lastname[]
// Reinsert data
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (5b6962dd-3f90-4c93-8f61-eabfa4a803e2, 'VOS','Marianne');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (e7cd5752-bc0d-4157-a80f-7523add8dbcd, 'VAN DER BREGGEN','Anna');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (e7ae5cf3-d358-4d99-b900-85902fda9bb0, 'FRAME','Alex');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (220844bf-4860-49d6-9a4b-6b5d3a79cbfb, 'TIRALONGO','Paolo');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47, 'KRUIKSWIJK','Steven');
INSERT INTO cycling.cyclist_name (id, lastname, firstname) VALUES (fb372533-eb95-4bb4-8685-6ef61e994caa, 'MATTHEWS', 'Michael');
// tag::comment[]
ALTER TABLE cycling.cyclist_name
ADD comment text;
// end::comment[]
// tag::update_set_comment[]
UPDATE cycling.cyclist_name
SET comment = 'Rides hard, gets along with others, a real winner'
WHERE id = fb372533-eb95-4bb4-8685-6ef61e994caa;
UPDATE cycling.cyclist_name
SET comment = 'Rides fast, does not get along with others, a real dude'
WHERE id = 5b6962dd-3f90-4c93-8f61-eabfa4a803e2;
// end::update_set_comment[]
DROP INDEX IF EXISTS cycling.stdanalyzer_idx;
// tag::stdanalyzer_idx[]
CREATE CUSTOM INDEX IF NOT EXISTS stdanalyzer_idx
ON cycling.cyclist_name (comment) USING 'org.apache.cassandra.index.sasi.SASIIndex'
WITH OPTIONS = {
'mode': 'CONTAINS',
'analyzer_class': 'org.apache.cassandra.index.sasi.analyzer.StandardAnalyzer',
'analyzed': 'true',
'tokenization_skip_stop_words': 'and, the, or',
'tokenization_enable_stemming': 'true',
'tokenization_normalize_lowercase': 'true',
'tokenization_locale': 'en'
};
// end::stdanalyzer_idx[]
SOURCE 'cyclist_name-queries.cql';
// Undo UPDATE statements
UPDATE cycling.cyclist_name
SET comment = NULL
WHERE id = fb372533-eb95-4bb4-8685-6ef61e994caa;
UPDATE cycling.cyclist_name
SET comment = NULL
WHERE id = 5b6962dd-3f90-4c93-8f61-eabfa4a803e2;
// tag::update[]
UPDATE cycling.cyclist_name
SET comment = 'Rides hard, gets along with others, a real winner'
WHERE id = fb372533-eb95-4bb4-8685-6ef61e994caa
IF EXISTS;
// end::update[]
// tag::multcolumns[]
UPDATE cycling.cyclist_name
SET
firstname = 'Marianne',
lastname = 'VOS'
WHERE id = 88b8fd18-b1ed-4e96-bf79-4280797cba80;
// end::multcolumns[]
// tag::records[]
UPDATE cycling.cyclist_name
SET firstname = NULL
WHERE id IN (
5b6962dd-3f90-4c93-8f61-eabfa4a803e2,
fb372533-eb95-4bb4-8685-6ef61e994caa
);
// end::records[]
// tag::upsert[]
UPDATE cycling.cyclist_name
SET
firstname = 'Anna',
lastname = 'VAN DER BREGGEN'
WHERE id = e7cd5752-bc0d-4157-a80f-7523add8dbcd;
// end::upsert[]
// tag::if[]
UPDATE cycling.cyclist_name
SET comment = 'Rides hard, gets along with others, a real winner'
WHERE id = fb372533-eb95-4bb4-8685-6ef61e994caa
IF comment = NULL;
// end::if[]
// tag::fail[]
UPDATE cycling.cyclist_name
SET comment = 'Rides hard, gets along with others, a real winner'
WHERE id = fb372533-eb95-4bb4-8685-6ef61e994cac
IF comment = 'Rides hard, gets along with others, a real winner';
// end::fail[]
// tag::count_lastname[]
SELECT COUNT(lastname)
FROM cycling.cyclist_name;
// end::count_lastname[]
// tag::count_rows[]
SELECT COUNT(*)
FROM cycling.cyclist_name;
// end::count_rows[]
// tag::insert_Roxxane[]
INSERT INTO cycling.cyclist_name (
id, lastname, firstname
) VALUES (
4647f6d3-7bd2-4085-8d6c-1229351b5498, 'KNETEMANN', 'Roxxane'
)
IF NOT EXISTS;
// end::insert_Roxxane[]
// tag::update_Roxxane[]
UPDATE cycling.cyclist_name
SET firstname = 'Roxane'
WHERE id = 4647f6d3-7bd2-4085-8d6c-1229351b5498
IF firstname = 'Roxxane';
// end::update_Roxxane[]
DELETE FROM cycling.cyclist_name
WHERE id = 4647f6d3-7bd2-4085-8d6c-1229351b5498;

62
doc/modules/cassandra/examples/CQL/cyclist_races-table.cql Normal file
View File

@ -0,0 +1,62 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
DROP TABLE IF EXISTS cycling.cyclist_races;
// Find all races for a particular cyclist
// CREATE TYPE - User-Defined Type, race
// CREATE TABLE WITH LIST, SIMPLE PRIMARY KEY
SOURCE 'user-defined-type-create-race.cql';
// tag::frozenlist[]
CREATE TABLE IF NOT EXISTS cycling.cyclist_races (
id UUID PRIMARY KEY,
lastname text,
firstname text,
races list<FROZEN <race>>
);
// end::frozenlist[]
// tag::insertFL[]
INSERT INTO cycling.cyclist_races (
id,
lastname,
firstname,
races
) VALUES (
5b6962dd-3f90-4c93-8f61-eabfa4a803e2,
'VOS',
'Marianne',
[ {
race_title:'Rabobank 7-Dorpenomloop Aalburg',
race_date:'2015-05-09',
race_time:'02:58:33'},
{
race_title:'Ronde van Gelderland',
race_date:'2015-04-19',
race_time:'03:22:23'
}
]
);
// end::insertFL[]
INSERT INTO cycling.cyclist_races (
id, lastname, firstname, races
) VALUES (
e7cd5752-bc0d-4157-a80f-7523add8dbcd, 'VAN DER BREGGEN', 'Anna', [ {race_title:'Festival Luxembourgeois du cyclisme feminin Elsy Jacobs - Prologue - Garnich > Garnich',race_date:'2015-05-01',race_time:'08:13:00'},{race_title:'Festival Luxembourgeois du cyclisme feminin Elsy Jacobs - Stage 2 - Garnich > Garnich',race_date:'2015-05-02',race_time:'02:41:52'},{race_title:'Festival Luxembourgeois du cyclisme feminin Elsy Jacobs - Stage 3 - Mamer > Mamer',race_date:'2015-05-03',race_time:'02:31:24'} ]
);
// tag::add[]
ALTER TABLE cycling.cyclist_races
ADD manager UUID;
// end::add[]
// tag::list[]
ALTER TABLE cycling.cyclist_races
ADD completed list<text>;
// end::list[]
// tag::drop[]
ALTER TABLE cycling.cyclist_races
DROP manager;
// end::drop[]

42
doc/modules/cassandra/examples/CQL/popular_count-table.cql Normal file
View File

@ -0,0 +1,42 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
DROP TABLE IF EXISTS cycling.popular_count;
// tag::create[]
CREATE TABLE IF NOT EXISTS cycling.popular_count (
id UUID PRIMARY KEY,
popularity counter
);
// end::create[]
// tag::batch[]
BEGIN COUNTER BATCH
UPDATE cycling.popular_count
SET popularity = popularity + 1
WHERE id = 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47;
UPDATE cycling.popular_count
SET popularity = popularity + 125
WHERE id = 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47;
UPDATE cycling.popular_count
SET popularity = popularity - 64
WHERE id = 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47;
APPLY BATCH;
// end::batch[]
// tag::count[]
UPDATE cycling.popular_count
SET popularity = popularity + 2
WHERE id = 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47;
// end::count[]
CAPTURE 'select_all_from_popular_count.results';
// tag::select[]
SELECT *
FROM cycling.popular_count;
// end::select[]
CAPTURE OFF;

43
doc/modules/cassandra/examples/CQL/race_times-table.cql Normal file
View File

@ -0,0 +1,43 @@
SOURCE 'race_times-table.cql';
// tag::duration[]
INSERT INTO cycling.race_times (
finish_time,
race_name, cyclist_name, race_date
) VALUES (
1h4m48s20ms,
'17th Santos Tour Down Under', 'Rohan DENNIS', '2017-04-14'
);
// end::duration[]
// tag::update_duration[]
UPDATE cycling.race_times
SET finish_time = 2h5m22s14ms
WHERE race_name = '17th Santos Tour Down Under'
AND cyclist_name = 'Rohan DENNIS'
AND race_date = '2017-04-14';
// end::update_duration[]
CAPTURE 'select_all_from_race_times.results';
// tag::select_duration[]
SELECT *
FROM cycling.race_times
WHERE race_name = '17th Santos Tour Down Under'
AND cyclist_name = 'Rohan DENNIS'
AND race_date = '2017-04-14';
// end::select_duration[]
CAPTURE OFF;
// tag::select_race_times_where_race_date_is_calculation[]
SELECT *
FROM cycling.race_times
WHERE race_date = '2017-04-15' - 1d;
// end::select_race_times_where_race_date_is_calculation[]
// tag::rename[]
ALTER TABLE cycling.race_times
RENAME race_date TO date;
// end::rename[]
ALTER TABLE cycling.race_times
RENAME date TO race_date;

73
doc/modules/cassandra/examples/CQL/race_winners-table.cql Normal file
View File

@ -0,0 +1,73 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
DROP TABLE IF EXISTS cycling.race_winners;
SOURCE 'user-defined-type-create-fullname.cql';
// tag::usetype[]
CREATE TABLE IF NOT EXISTS cycling.race_winners (
cyclist_name FROZEN<fullname>,
race_name text,
race_position int,
PRIMARY KEY (race_name, race_position)
);
// end::usetype[]
// tag::insert[]
INSERT INTO cycling.race_winners (
race_name, race_position,
cyclist_name
) VALUES (
'National Championships South Africa WJ-ITT (CN)', 1,
{ firstname:'Frances', lastname:'DU TOUT' }
);
// end::insert[]
INSERT INTO cycling.race_winners (
race_name, race_position,
cyclist_name
) VALUES (
'National Championships South Africa WJ-ITT (CN)', 2,
{ firstname:'Lynette', lastname:'BENSON' }
);
INSERT INTO cycling.race_winners (
race_name, race_position,
cyclist_name
) VALUES (
'National Championships South Africa WJ-ITT (CN)', 3,
{ firstname:'Anja', lastname:'GERBER' }
);
INSERT INTO cycling.race_winners (
race_name, race_position,
cyclist_name
) VALUES (
'National Championships South Africa WJ-ITT (CN)', 4,
{ firstname:'Ame', lastname:'VENTER' }
);
INSERT INTO cycling.race_winners (
race_name, race_position,
cyclist_name
) VALUES (
'National Championships South Africa WJ-ITT (CN)', 5,
{ firstname:'Danielle', lastname:'VAN NIEKERK' }
);
// tag::comment_hyphens[]
SELECT * FROM cycling.race_winners; -- End of line comment
// end::comment_hyphens[]
// tag::comment_slashes[]
SELECT * FROM cycling.race_winners; // End of line comment
// end::comment_slashes[]
// tag::comment_span[]
/* This is a
comment that spans multiple
lines */
SELECT * FROM cycling.race_winners;
// end::comment_span[]

136
doc/modules/cassandra/examples/CQL/rank_by_year_and_name-table.cql Normal file
View File

@ -0,0 +1,136 @@
SOURCE 'keyspace-create-simple.cql';
SOURCE 'keyspace-use.cql';
DROP TABLE IF EXISTS cycling.rank_by_year_and_name;
// Store race information by year and race name using a COMPOSITE PARTITION KEY
// tag::use_and_compositepk[]
USE cycling;
CREATE TABLE rank_by_year_and_name (
race_year int,
race_name text,
cyclist_name text,
rank int,
PRIMARY KEY ((race_year, race_name), rank)
);
// end::use_and_compositepk[]
DROP TABLE IF EXISTS cycling.rank_by_year_and_name;
// tag::compositepk[]
CREATE TABLE IF NOT EXISTS cycling.rank_by_year_and_name (
race_year int,
race_name text,
cyclist_name text,
rank int,
PRIMARY KEY ((race_year, race_name), rank)
);
// end::compositepk[]
// tag::dropindex[]
DROP INDEX IF EXISTS cycling.rank_idx;
// end::dropindex[]
// tag::createindex[]
CREATE INDEX IF NOT EXISTS rank_idx
ON cycling.rank_by_year_and_name (rank);
// end::createindex[]
// tag::drop_race_year_idx[]
DROP INDEX IF EXISTS cycling.race_year_idx;
// end::drop_race_year_idx[]
// tag::create_race_year_idx[]
CREATE INDEX IF NOT EXISTS race_year_idx ON
cycling.rank_by_year_and_name (race_year);
// end::create_race_year_idx[]
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2015, 'Tour of Japan - Stage 4 - Minami > Shinshu', 'Benjamin PRADES', 1);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2015, 'Tour of Japan - Stage 4 - Minami > Shinshu', 'Adam PHELAN', 2);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2015, 'Tour of Japan - Stage 4 - Minami > Shinshu', 'Thomas LEBAS', 3);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2014, 'Tour of Japan - Stage 4 - Minami > Shinshu', 'Benjamin PRADES', 3);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2014, 'Tour of Japan - Stage 4 - Minami > Shinshu', 'Daniel MARTIN', 1);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2014, 'Tour of Japan - Stage 4 - Minami > Shinshu', 'Johan Esteban CHAVES', 2);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2015, 'Giro d''Italia - Stage 11 - Forli > Imola', 'Ilnur ZAKARIN', 1);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2015, 'Giro d''Italia - Stage 11 - Forli > Imola', 'Carlos BETANCUR', 2);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2014, '4th Tour of Beijing', 'Phillippe GILBERT', 1);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2014, '4th Tour of Beijing', 'Daniel MARTIN', 2);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2014, '4th Tour of Beijing', 'Johan Esteban CHAVES', 3);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2014, '4th Tour of Beijing', 'Phillippe GILBERT', 1);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2014, '4th Tour of Beijing', 'Daniel MARTIN', 2);
INSERT INTO cycling.rank_by_year_and_name (race_year, race_name, cyclist_name, rank) VALUES (2014, '4th Tour of Beijing', 'Johan Esteban CHAVES', 3);
// Show all inserted data
CAPTURE 'select_all_from_rank_by_year_and_name.results';
SELECT *
FROM cycling.rank_by_year_and_name;
CAPTURE OFF;
CAPTURE 'select_all_from_rank_by_year_and_name_Japan_2014.results';
// tag::select_with_name_and_year[]
SELECT *
FROM cycling.rank_by_year_and_name
WHERE race_year = 2014
AND race_name = 'Tour of Japan - Stage 4 - Minami > Shinshu';
// end::select_with_name_and_year[]
CAPTURE OFF;
// tag::sepstatementswithand[]
SELECT
rank,
cyclist_name AS name
FROM cycling.rank_by_year_and_name
WHERE "race_name" = 'Tour of Japan - Stage 4 - Minami > Shinshu'
AND race_year = 2014;
// end::sepstatementswithand[]
// tag::columnalias[]
CAPTURE 'select_best_rank_from_rank_by_year_and_name.results';
SELECT
MIN(rank) AS best_rank,
cyclist_name
FROM cycling.rank_by_year_and_name
WHERE "race_name" = 'Tour of Japan - Stage 4 - Minami > Shinshu'
AND race_year = 2014;
// end::columnalias[]
CAPTURE OFF;
// The following query generates a warning, which is normal
// tag::countrows[]
SELECT COUNT(*)
FROM cycling.rank_by_year_and_name;
// end::countrows[]
// tag::limitrows[]
SELECT cyclist_name
FROM cycling.rank_by_year_and_name
LIMIT 50000;
// end::limitrows[]
// Query by partition
CAPTURE 'select_all_from_rank_by_year_and_name_partition_limit.results';
// tag::partlimit[]
SELECT *
FROM cycling.rank_by_year_and_name
PER PARTITION LIMIT 2;
// end::partlimit[]
CAPTURE OFF;
// Select rank - filter on a clustering column
CAPTURE 'select_all_from_rank_by_year_and_name_rank_1.results';
// tag::selectrank[]
SELECT *
FROM cycling.rank_by_year_and_name
WHERE rank = 1;
// end::selectrank[]
CAPTURE OFF;
CAPTURE 'select_all_from_rank_by_year_and_name_2014.results';
// tag::select_with_year[]
SELECT *
FROM cycling.rank_by_year_and_name
WHERE race_year = 2014;
// end::select_with_year[]
CAPTURE OFF;

1
doc/modules/cassandra/examples/CQLSH/comments-desc_table.cqlsh Normal file
View File

@ -0,0 +1 @@
DESC cycling.comments;

21
doc/modules/cassandra/examples/RESULTS/comments-desc_table.result Normal file
View File

@ -0,0 +1,21 @@
CREATE TABLE cycling.comments (
id uuid,
created_at timestamp,
comment text,
commenter text,
record_id timeuuid,
PRIMARY KEY (id, created_at)
) WITH CLUSTERING ORDER BY (created_at DESC)
AND bloom_filter_fp_chance = 0.01
AND caching = {'keys': 'NONE', 'rows_per_partition': '10'}
AND comment = ''
AND compaction = {'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'enabled': 'true', 'max_threshold': '32', 'min_threshold': '4'}
AND compression = {'chunk_length_in_kb': '64', 'class': 'org.apache.cassandra.io.compress.DeflateCompressor'}
AND crc_check_chance = 1.0
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 speculative_retry = '99PERCENTILE';

7
doc/modules/cassandra/examples/RESULTS/select_after_batch_food_from_cyclist_expenses.result Normal file
View File

@ -0,0 +1,7 @@
cyclist_name | expense_id | balance | amount | description | paid
--------------+------------+---------+--------+-------------+-------
Vera ADRIAN | 1 | -32.95 | 7.95 | Breakfast | False
Vera ADRIAN | 2 | -32.95 | 13.44 | Lunch | True
Vera ADRIAN | 3 | -32.95 | 25 | Dinner | False
(3 rows)

7
doc/modules/cassandra/examples/RESULTS/select_after_batch_paid_from_cyclist_expenses.result Normal file
View File

@ -0,0 +1,7 @@
cyclist_name | expense_id | balance | amount | description | paid
--------------+------------+---------+--------+-------------+------
Vera ADRIAN | 1 | 0 | 7.95 | Breakfast | True
Vera ADRIAN | 2 | 0 | 13.44 | Lunch | True
Vera ADRIAN | 3 | 0 | 25 | Dinner | True
(3 rows)

5
doc/modules/cassandra/examples/RESULTS/select_after_update_from_cyclist_expenses.result Normal file
View File

@ -0,0 +1,5 @@
cyclist_name | expense_id | balance | amount | description | paid
--------------+------------+---------+--------+-------------+-------
Vera ADRIAN | 1 | -7.95 | 7.95 | Breakfast | False
(1 rows)

8
doc/modules/cassandra/examples/RESULTS/select_initial_from_country_flag.result Normal file
View File

@ -0,0 +1,8 @@
country | cyclist_name | flag
---------+--------------+------
Belgium | Andre | 1
Belgium | Jacques | 1
France | Andre | 3
France | George | 3
(4 rows)

5
doc/modules/cassandra/examples/RESULTS/select_initial_from_cyclist_expenses.result Normal file
View File

@ -0,0 +1,5 @@
cyclist_name | expense_id | balance | amount | description | paid
--------------+------------+---------+--------+-------------+-------
Vera ADRIAN | 1 | 0 | 7.95 | Breakfast | False
(1 rows)

3
doc/modules/cassandra/examples/RESULTS/true.result Normal file
View File

@ -0,0 +1,3 @@
[applied]
-----------
True

10
doc/modules/cassandra/nav.adoc
View File

@ -2,9 +2,10 @@
** xref:cassandra:overview/faq/index.adoc[]
** xref:cassandra:getting-started/index.adoc[]
** xref:cassandra:getting-started/index.adoc[]
*** xref:cassandra:getting-started/cassandra-quickstart.adoc[]
*** xref:cassandra:getting-started/sai-quickstart.adoc[]
*** xref:cassandra:getting-started/vector-search-quickstart.adoc[]
*** xref:cassandra:installing/installing.adoc[]
*** xref:cassandra:getting-started/configuring.adoc[]
*** xref:cassandra:getting-started/querying.adoc[]
@ -17,7 +18,7 @@
** xref:cassandra:architecture/index.adoc[]
*** xref:cassandra:architecture/overview.adoc[]
*** xref:cassandra:architecture/dynamo.adoc[]
*** xref:cassandra:architecture/dynamo.adoc[]
*** xref:cassandra:architecture/storage-engine.adoc[]
*** xref:cassandra:architecture/guarantees.adoc[]
*** xref:cassandra:architecture/messaging.adoc[]
@ -66,8 +67,9 @@
** xref:cassandra:vector-search/overview.adoc[]
*** xref:cassandra:vector-search/concepts.adoc[]
**** xref:cassandra:vector-search/data-modeling.adoc[]
*** xref:cassandra:vector-search/quickstarts.adoc[]
**** xref:cassandra:getting-started/vector-search-quickstart.adoc[]
// *** xref:cassandra:vector-search/quickstarts.adoc[]
*** xref:cassandra:getting-started/vector-search-quickstart.adoc[]
*** xref:cassandra:vector-search/vector-search-working-with.adoc[]
// **** xref:getting-started/sai-quickstart.adoc[]
** xref:cassandra:managing/index.adoc[]

10
doc/modules/cassandra/pages/new/index.adoc
View File

@ -1,17 +1,23 @@
= New Features
:navtitle: What's new
== New Features in Apache Cassandra 5.1
This section covers the new features in Apache Cassandra 5.1.
* https://cwiki.apache.org/confluence/x/FQRACw[ACID Transactions (Accord)]
* https://cwiki.apache.org/confluence/x/YyD1D[Transactional Cluster Metadata]
== New Features in Apache Cassandra 5.0
This section covers the new features in Apache Cassandra 5.0.
* https://cwiki.apache.org/confluence/x/FQRACw[ACID Transactions (Accord)]
* https://issues.apache.org/jira/browse/CASSANDRA-16052[Storage Attached Indexes]
* https://issues.apache.org/jira/browse/CASSANDRA-17240[Trie Memtables]
* https://issues.apache.org/jira/browse/CASSANDRA-18398[Trie SSTables]
* https://github.com/apache/cassandra/blob/trunk/NEWS.txt[More Guardrails]
* https://issues.apache.org/jira/browse/CASSANDRA-8877[TTL and writetime on collections and UDTs]
* https://cwiki.apache.org/confluence/x/YyD1D[Transactional Cluster Metadata]
* https://issues.apache.org/jira/browse/CASSANDRA-16895[JDK 17]
* https://issues.apache.org/jira/browse/CASSANDRA-17221[New Mathematical CQL functions: abs, exp, log, log10 and round]
* https://issues.apache.org/jira/browse/CASSANDRA-18060[New CQL native scalar functions for collections]

9
doc/modules/cassandra/pages/reference/cql-commands/create-index.adoc
View File

@ -21,7 +21,12 @@ include::example$BNF/index_name.bnf[]
CREATE INDEX [ IF NOT EXISTS ] <index_name>
ON [<keyspace_name>.]<table_name>
([ ( KEYS | FULL ) ] <column_name>)
(ENTRIES <column_name>) ;
(ENTRIES <column_name>)
// | [ (KEYS(<map_name>)) ]
// | [ (VALUES(<map_name>)) ]
// | [ (ENTRIES(<map_name>)) ]
[USING 'sai'
[ WITH OPTIONS = { <option_map> } ]];
----
// end::syntax[]
@ -47,7 +52,7 @@ Enclose in quotes to use special characters or preserve capitalization.
If no name is specified, {product} names the index: `<table_name>_<column_name>_idx`.
*keyspace_name*::
Name of the keyspace that contains the table to index.
Name of the keyspace that contains the table to index.
If no name is specified, the current keyspace is used.
== Usage notes

98
doc/modules/cassandra/pages/reference/cql-commands/create-table-examples.adoc Normal file
View File

@ -0,0 +1,98 @@
= Examples
:description: CREATE TABLE CQL examples.
== Create a table with UUID as the primary key
Create the `cyclist_name` table with UUID as the primary key:
[source,language-cql]
----
include::cassandra:example$CQL/cyclist_name-table.cql[tag=simple]
----
== Create a compound primary key
Create the `cyclist_category` table and store the data in reverse order:
[source,language-cql]
----
include::cassandra:example$CQL/cyclist_category-table.cql[tag=cpartitionkey]
----
== Create a composite partition key
Create a table that is optimized for query by cyclist rank by year:
[source,language-cql]
----
include::cassandra:example$CQL/rank_by_year_and_name-table.cql[tag=compositepk]
----
== Create a table with a vector column
Create a table with a vector column
[source,language-cql]
----
include::cassandra:example$CQL/vector-search/vector-search-cycling.cql[tag=create-vs-table]
----
== Create a table with a frozen UDT
Create the `race_winners` table that has a frozen user-defined type (UDT):
[source,language-cql]
----
include::cassandra:example$CQL/race_winners-table.cql[tag=usetype]
----
See xref:developing/user-defined-type-create.adoc[Create a user-defined type] for information on Create UDTs.
UDTs can be created unfrozen if only non-collection fields are used in the user-defined type creation.
If the table is created with an unfrozen UDT, then xref:developing/inserting/insert-user-defined-type.adoc[individual field values can be updated and deleted].
== Create a table with a CDC log
Create a change data capture log for the `cyclist_id` table:
[source,language-cql]
----
include::cassandra:example$CQL/cyclist_id-table.cql[tag=comp_pk]
----
CDC logging must be enabled in cassandra.yaml.
[CAUTION]
====
Before enabling CDC logging, have a plan for moving and consuming the log information.
After the disk space limit is reached, writes to CDC-enabled tables are rejected until more space is freed.
See https://docs.datastax.com/en/dse/6.8/dse-admin/datastax_enterprise/config/configCassandra_yaml.html#configCassandra_yaml__cdcSpaceSection[Change-data-capture (CDC) space settings] for information about available CDC settings.
====
== Storing data in descending order
The following example shows a table definition that stores the categories with the highest points first.
[source,language-cql]
----
include::cassandra:example$CQL/cyclist_category-table.cql[tag=cpartitionkey]
----
[[restore-commit-log]]
== Restoring from the table ID for commit log replay
Recreate a table with its original ID to facilitate restoring table data by replaying commit logs:
[source,language-cql]
----
include::cassandra:example$CQL/cyclist_emails-table.cql[tag=ID]
----
To retrieve a table's ID, query the `id` column of `system_schema.tables`.
For example:
[source,language-cql]
----
include::cassandra:example$CQL/cyclist_emails-table.cql[tag=select_id_from_system_schema]
----
To perform a restoration of the table, see xref:managing/operating/backups.adoc[Backups] for more information.

95
doc/modules/cassandra/pages/reference/cql-commands/create-table.adoc Normal file
View File

@ -0,0 +1,95 @@
= CREATE TABLE
:description: Defines the columns of a new table.
{description}
{product} supports creating a new https://cassandra.apache.org/_/glossary.html#table[table] in the selected keyspace.
Use `IF NOT EXISTS` to suppress the error message if the table already exists;
no table is created.
A xref:cassandra:reference/static.adoc[static column] can store the same data in multiple clustered rows of a partition, and then retrieve that data with a single `SELECT` statement.
Tables support a single xref:developing/cql/counter-column.adoc[counter column].
*See also:* xref:cassandra:reference/cql-commands/alter-table.adoc[ALTER TABLE],
xref:cassandra:reference/cql-commands/drop-table.adoc[DROP TABLE],
xref:cassandra:reference/cql-commands/create-custom-index.adoc[CREATE CUSTOM INDEX] for Storage-Attached Indexes (SAI), xref:cassandra:reference/cql-commands/create-index.adoc[CREATE INDEX] for secondary indexes (2i)
== Syntax
BNF definition:
[source,bnf]
----
include::cassandra:example$BNF/create_table.bnf[]
----
// tag::syntax[]
----
CREATE TABLE [ IF NOT EXISTS ] [<keyspace_name>.]<table_name>
( <column_definition> [ , ... ] | PRIMARY KEY (column_list) )
[ WITH [ <table_options> ]
[ [ AND ] CLUSTERING ORDER BY [ <clustering_column_name> (ASC | DESC) ] ]
[ [ AND ] ID = '<table_hash_tag>' ] ] ;
----
// end::syntax[]
.Syntax legend
[%collapsible]
====
include::partial$cql-syntax-legend.adoc[]
====
== Required parameters
*table_name*::
Name of the table to index.
*column_name*::
Name of the column.
// Column Definitions
include::cassandra:partial$table-column-definitions.adoc[]
// Primary Key
include::cassandra:partial$primary-key-column.adoc[]
// Table Options
include::cassandra:partial$table-properties.adoc[]
// Compression
include::cassandra:partial$compress-subproperties.adoc[]
// Compaction
include::cassandra:partial$compact-subproperties.adoc[]
== Optional parameters
// Table Keywords
include::cassandra:partial$cluster-order.adoc[]
*index_name*::
Name of the index.
Enclose in quotes to use special characters or preserve capitalization.
If no name is specified, {product} names the index: `<table_name>_<column_name>_idx`.
*keyspace_name*::
Name of the keyspace that contains the table to index.
If no name is specified, the current keyspace is used.
== Usage notes
If the column already contains data, it is indexed during the execution of this statement.
After an index has been created, it is automatically updated when data in the column changes.
Indexing with the `CREATE INDEX` command can impact performance.
Before creating an index, be aware of when and xref:cassandra:developing/indexing/2i/2i-when-to-use.adoc#when-no-index[when not to create an index].
*Restriction:* Indexing counter columns is not supported.
include::create-table-examples.adoc[leveloffset=+1]

52
doc/modules/cassandra/pages/reference/cql-commands/drop-table.adoc Normal file
View File

@ -0,0 +1,52 @@
= DROP TABLE
:description: Immediate, irreversible removal of a table, including all data contained in the table.
{description}
*Restriction:* xref:reference:cql-commands/drop-materialized-view.adoc[Drop all materialized views] associated with the table before dropping the table.
An error message lists any materialized views that are based on the table: `+InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot drop table when materialized views still depend on it (cycling.{cyclist_by_age})"+`
*See also:* xref:cassandra:reference/cql-commands/create-table.adoc[CREATE TABLE],
xref:cassandra:reference/cql-commands/alter-table.adoc[ALTER TABLE],
xref:cassandra:reference/cql-commands/create-custom-index.adoc[CREATE CUSTOM INDEX] for Storage-Attached Indexes (SAI), xref:cassandra:reference/cql-commands/create-index.adoc[CREATE INDEX] for secondary indexes (2i)
== Syntax
BNF definition:
[source,bnf]
----
include::cassandra:example$BNF/drop_table.bnf[]
----
// tag::syntax[]
----
DROP TABLE [ IF EXISTS ] [<keyspace_name>.]<table_name> ;
----
// end::syntax[]
.Syntax legend
[%collapsible]
====
include::cassandra:partial$cql-syntax-legend.adoc[]
====
== Required parameters
*table_name*::
Name of the table to drop.
== Optional parameters
*keyspace_name*::
Name of the keyspace that contains the table to drop.
If no name is specified, the current keyspace is used.
== Examples
Drop the `cyclist_name` table:
[source,language-cql]
----
include::cassandra:example$CQL/cyclist_name-table.cql[tag=droptble]
----

8
doc/modules/cassandra/pages/vector-search/_query-vector-data-cycling.adoc
View File

@ -1,24 +1,24 @@
= Query vector data with CQL
To query data using Vector Search, use a `SELECT` query:
To query data using Vector Search, use a `SELECT` query:
[source,cql]
----
include::example$CQL/vector-search/vector-search-cycling.cql[tag=select-vector-data-cycling]
----
To obtain the distance calculation of the best scoring node closest to the query data as part of the results, use a `SELECT` query:
To obtain the similarity calculation of the best scoring node closest to the query data as part of the results, use a `SELECT` query:
[source,cql]
----
include::example$CQL/vector-search/vector-search-cycling.cql[tag=select-vector-data-similarity-cycling]
----
The supported functions for this type of query are:
The supported functions for this type of query are:
* similarity_dot_product
* similarity_cosine
* similarity_euclidean
* similarity_euclidean
with the parameters of (<vector_column>, <embedding_value>).
Both parameters represent vectors.

6
doc/modules/cassandra/pages/vector-search/overview.adoc
View File

@ -21,10 +21,10 @@ Create, check, alter, drop, and query Vector Search.
// xref:cassandra:vector-search/vector-search-operations.adoc[Vector Search operations]::
// Configuring and monitoring.
xref:cassandra:vector-search/vector-search-query.adoc[Querying with Vector Search]::
Understand how to run Vector Search queries.
// xref:cassandra:vector-search/vector-search-query.adoc[Querying with Vector Search]::
// Understand how to run Vector Search queries.
xref:cassandra:vector-search/data-modeling.adoc[Data modeling with Vector Search]::
The ins and outs of data modeling with Vector Search.
*Reference:* xref:cassandra:reference/cql-commands/create-table.adoc[CREATE TABLE], xref:cassandra:reference/cql-commands/create-custom-index.adoc[CREATE CUSTOM INDEX]
*Reference:* xref:cassandra:reference/cql-commands/create-table.adoc[CREATE TABLE], xref:cassandra:reference/cql-commands/create-index.adoc[CREATE INDEX], xref:cassandra:reference/cql-commands/create-custom-index.adoc[CREATE CUSTOM INDEX]

13
doc/modules/cassandra/pages/vector-search/vector-search-working-with.adoc Normal file
View File

@ -0,0 +1,13 @@
= Working with Vector Search
include::_create-vector-keyspace-cycling.adoc[leveloffset=+1]
include::_use-vector-keyspace-cycling.adoc[leveloffset=+1]
include::_create-vector-table-cycling.adoc[leveloffset=+1]
include::_create-vector-index-cycling.adoc[leveloffset=+1]
include::_load-vector-data-cycling.adoc[leveloffset=+1]
include::_query-vector-data-cycling.adoc[leveloffset=+1]

14
doc/modules/cassandra/partials/cluster-order.adoc Normal file
View File

@ -0,0 +1,14 @@
=== Table keywords
*CLUSTERING ORDER BY ( column_name ASC | DESC)* ::
Order rows storage to make use of the on-disk sorting of columns.
Specifying order can make query results more efficient.
Options are:
+
`ASC`: ascending (default order)
+
`DESC`: descending, reverse order
*ID* ::
If a table is accidentally dropped with xref:reference/cql-commands/drop-table.adoc[DROP TABLE], use this option to
xref:reference/cql-commands/create-table.adoc#restore-commit-log[recreate the table] and run a commit log replay to retrieve the data.

262
doc/modules/cassandra/partials/compact-subproperties.adoc Normal file
View File

@ -0,0 +1,262 @@
=== compaction = \{compaction_map}
:description: Construct a map of the compaction option and its subproperties.
Defines the strategy for cleaning up data after writes.
Syntax uses a simple JSON format:
[source,language-cql]
----
compaction = {
'class' : '<compaction_strategy_name>',
'<property_name>' : <value> [, ...] }
----
where the <compaction_strategy_name> is xref:STCS[SizeTieredCompactionStrategy], xref:TWCS[TimeWindowCompactionStrategy], or xref:LCS[LeveledCompactionStrategy].
[IMPORTANT]
====
Use only compaction implementations bundled with {product}.
See xref:managing/operating/compaction/index.adoc[Compaction] for more details.
====
==== Common properties
The following properties apply to all compaction strategies.
[source,language-cql]
----
compaction = {
'class' : 'compaction_strategy_name',
'enabled' : (true | false),
'log_all' : (true | false),
'only_purge_repaired_tombstone' : (true | false),
'tombstone_threshold' : <ratio>,
'tombstone_compaction_interval' : <sec>,
'unchecked_tombstone_compaction' : (true | false),
'min_threshold' : <num_sstables>,
'max_threshold' : <num_sstables> }
----
*enabled* ::
Enable background compaction.
* `true` runs minor compactions.
* `false` disables minor compactions.
+
[TIP]
====
Use `nodetool enableautocompaction` to start running compactions.
====
{empty}::
Default: `true`
*log_all* ::
Activates advanced logging for the entire cluster.
+
Default: `false`
*only_purge_repaired_tombstone* ::
Enabling this property prevents data from resurrecting when repair is not run within the `gc_grace_seconds`.
When its been a long time between repairs, the database keeps all tombstones.
+
* `true` - Only allow tombstone purges on repaired SSTables.
* `false` - Purge tombstones on SSTables during compaction even if the table has not been repaired.
+
Default: `false`
*tombstone_threshold* ::
The ratio of garbage-collectable tombstones to all contained columns.
If the ratio exceeds this limit, compactions starts only on that table to purge the tombstones.
+
Default: `0.2`
*tombstone_compaction_interval* ::
Number of seconds before compaction can run on an SSTable after it is created.
An SSTable is eligible for compaction when it exceeds the `tombstone_threshold`.
Because it might not be possible to drop tombstones when doing a single SSTable compaction, and since the compaction is triggered base on an estimated tombstone ratio, this setting makes the minimum interval between two single SSTable compactions tunable to prevent an SSTable from being constantly re-compacted.
+
Default: `86400` (1 day)
*unchecked_tombstone_compaction* ::
Setting to `true` allows tombstone compaction to run without pre-checking which tables are eligible for the operation.
Even without this pre-check, {product} checks an SSTable to make sure it is safe to drop tombstones.
+
Default: `false`
*min_threshold* ::
The minimum number of SSTables to trigger a minor compaction.
+
*Restriction:* Not used in `LeveledCompactionStrategy`.
+
Default: `4`
*max_threshold* ::
The maximum number of SSTables before a minor compaction is triggered.
+
*Restriction:* Not used in `LeveledCompactionStrategy`.
+
Default: `32`
[[STCS]]
==== SizeTieredCompactionStrategy
The compaction class `SizeTieredCompactionStrategy` (STCS) triggers a minor compaction when table meets the `min_threshold`.
Minor compactions do not involve all the tables in a keyspace.
See
xref:operating/compaction/stcs.adoc#stcs_options[SizeTieredCompactionStrategy (STCS)].
[NOTE]
====
Default compaction strategy.
====
The following properties only apply to SizeTieredCompactionStrategy:
[source,language-cql]
----
compaction = {
'class' : 'SizeTieredCompactionStrategy',
'bucket_high' : <factor>,
'bucket_low' : <factor>,
'min_sstable_size' : <int> }
----
*bucket_high* ::
Size-tiered compaction merges sets of SSTables that are approximately the same size.
The database compares each SSTable size to the average of all SSTable sizes for this table on the node.
It merges SSTables whose size in KB are within [average-size * bucket_low] and [average-size * bucket_high].
+
Default: `1.5`
*bucket_low* ::
Size-tiered compaction merges sets of SSTables that are approximately the same size.
The database compares each SSTable size to the average of all SSTable sizes for this table on the node.
It merges SSTables whose size in KB are within [average-size * bucket_low] and [average-size * bucket_high].
+
Default: `0.5`
*min_sstable_size* ::
STCS groups SSTables into buckets.
The bucketing process groups SSTables that differ in size by less than 50%.
This bucketing process is too fine-grained for small SSTables.
If your SSTables are small, use this option to define a size threshold in MB below which all SSTables belong to one unique bucket.
+
Default: `50` (MB)
[NOTE]
====
The `cold_reads_to_omit` property for
xref:operating/compaction/stcs.adoc#stcs_options[SizeTieredCompactionStrategy (STCS)] is no longer supported.
====
[[TWCS]]
==== TimeWindowCompactionStrategy
The compaction class `TimeWindowCompactionStrategy` (TWCS) compacts SSTables using a series of _time windows_ or _buckets_.
TWCS creates a new time window within each successive time period.
During the active time window, TWCS compacts all SSTables flushed from memory into larger SSTables using STCS.
At the end of the time period, all of these SSTables are compacted into a single SSTable.
Then the next time window starts and the process repeats.
See xref:operating/compaction/twcs.adoc#twcs_options[TimeWindowCompactionStrategy (TWCS)].
[NOTE]
====
All of the properties for STCS are also valid for TWCS.
====
The following properties apply only to TimeWindowCompactionStrategy:
[source,language-cql]
----
compaction = {
'class' : 'TimeWindowCompactionStrategy,
'compaction_window_unit' : <days>,
'compaction_window_size' : <int>,
'split_during_flush' : (true | false) }
----
*compaction_window_unit* ::
Time unit used to define the bucket size.
The value is based on the Java `TimeUnit`.
For the list of valid values, see the Java API `TimeUnit` page located at https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/TimeUnit.html.
+
Default: `days`
*compaction_window_size* ::
Units per bucket.
+
Default: `1`
[[LCS]]
==== LeveledCompactionStrategy
The compaction class `LeveledCompactionStrategy` (LCS) creates SSTables of a fixed, relatively small size (160 MB by default) that are grouped into levels.
Within each level, SSTables are guaranteed to be non-overlapping.
Each level (L0, L1, L2 and so on) is 10 times as large as the previous.
Disk I/O is more uniform and predictable on higher than on lower levels as SSTables are continuously being compacted into progressively larger levels.
At each level, row keys are merged into non-overlapping SSTables in the next level.
See https://docs.datastax.com/en/dse/6.8/dse-arch/datastax_enterprise/dbInternals/dbIntHowDataMaintain.html#dbIntHowDataMaintain__lcs-compaction[LeveledCompactionStrategy (LCS)].
[NOTE]
====
For more guidance, see https://www.datastax.com/dev/blog/when-to-use-leveled-compaction[When to Use Leveled Compaction] and https://www.datastax.com/dev/blog/leveled-compaction-in-apache-cassandra[Leveled Compaction] blog.
====
The following properties only apply to LeveledCompactionStrategy:
[source,language-cql]
----
compaction = {
'class' : 'LeveledCompactionStrategy,
'sstable_size_in_mb' : <int> }
----
*sstable_size_in_mb* ::
The target size for SSTables that use the LeveledCompactionStrategy.
Although SSTable sizes should be less or equal to sstable_size_in_mb, it is possible that compaction could produce a larger SSTable during compaction.
This occurs when data for a given partition key is exceptionally large.
The {product} database does not split the data into two SSTables.
+
Default: `160`
+
[CAUTION]
====
The default value, 160 MB, may be inefficient and negatively impact database indexing and the queries that rely on indexes.
For example, consider the benefit of using higher values for sstable_size_in_mb in tables that use (SAI) indexes.
For related information, see xref:developing/cql/indexing/sai/configuring.adoc#saiConfigure__saiCompactionStrategies[Compaction strategies].
====
==== DateTieredCompactionStrategy (deprecated)
[IMPORTANT]
====
Use xref:TWCS[TimeWindowCompactionStrategy] instead.
====
Stores data written within a certain period of time in the same SSTable.
*base_time_seconds* ::
The size of the first time window.
+
Default: `3600`
*max_sstable_age_days (deprecated)* ::
{product} does not compact SSTables if its most recent data is older than this property.
Fractional days can be set.
+
Default: `1000`
*max_window_size_seconds* ::
The maximum window size in seconds.
+
Default: `86400`
*timestamp_resolution* ::
Units, <MICROSECONDS> or <MILLISECONDS>, to match the timestamp of inserted data.
+
Default: `MICROSECONDS`

9
doc/modules/cassandra/partials/compaction-strategies.adoc Normal file
View File

@ -0,0 +1,9 @@
|===
| Compaction Strategy | | |
| xref:managing/operating/compaction/ucs.adoc[UCS]
| xref:managing/operating/compaction/ccs.adoc[LCS]
| xref:managing/operating/compaction/stsc.adoc[STCS]
| xref:managing/operating/compaction/twcs.adoc[TWCS]
|===

69
doc/modules/cassandra/partials/compress-subproperties.adoc Normal file
View File

@ -0,0 +1,69 @@
=== compression = { compression_map }
:description: Sets table compression.
Configure the `compression_map` by specifying the compression algorithm `class` followed by the subproperties in simple JSON format.
[TIP]
====
Implement custom compression classes using the `org.apache.cassandra.io.compress.ICompressor` interface.
====
[source, console]
----
compression = {
['class' : '<compression_algorithm_name>',
'chunk_length_in_kb' : '<value>',
'crc_check_chance' : '<value>',]
| 'sstable_compression' : '']
}
----
*class* ::
Sets the compressor name.
{product} provides the following built-in classes:
+
[width="100%",cols="40%,19%,11%,13%,6%,11%",options="header",]
|===
|Compression Algorithm |Cassandra Class |Compression |Decompression
|Ratio |C* Version
|https://lz4.github.io/lz4/[LZ4] |`LZ4Compressor` | A+ | A+ | C+ | `>=1.2.2`
|https://lz4.github.io/lz4/[LZ4HC] |`LZ4Compressor` | C+ | A+ | B+ | `>= 3.6`
|https://facebook.github.io/zstd/[Zstd] |`ZstdCompressor` | A- | A- | A+ | `>= 4.0`
|http://google.github.io/snappy/[Snappy] |`SnappyCompressor` | A- | A | C | `>= 1.0`
|https://zlib.net[Deflate (zlib)] |`DeflateCompressor` | C | C | A | `>= 1.0`
|===
+
[IMPORTANT]
====
Use only compression implementations bundled with {product}.
====
+
Choosing the right compressor depends on your requirements for space savings over read performance.
LZ4 is fastest to decompress, followed by Snappy, then by Deflate.
Compression effectiveness is inversely correlated with decompression speed.
The extra compression from Deflate or Snappy is not enough to make up for the decreased performance for general-purpose workloads, but for archival data they may be worth considering.
+
*Default*: `LZ4Compressor`.
*chunk_length_in_kb* ::
Size (in KB) of the block.
On disk, SSTables are compressed by block to allow random reads.
Values larger than the default value might improve the compression rate, but increases the minimum size of data to be read from disk when a read occurs.
The default value is a good middle ground for compressing tables.
Adjust compression size to account for read/write access patterns (how much data is typically requested at once) and the average size of rows in the table.
+
*Default*: `64`.
*crc_check_chance* ::
When compression is enabled, each compressed block includes a checksum of that block for the purpose of detecting disk bit rot and avoiding the propagation of corruption to other replica.
This option defines the probability with which those checksums are checked during read.
By default they are always checked.
Set to 0 to disable checksum checking and to 0.5, for instance, to check them on every other read.
+
*Default*: `1.0`.
*sstable_compression* ::
Disables compression.
Specify a null value.

29
doc/modules/cassandra/partials/primary-key-column.adoc Normal file
View File

@ -0,0 +1,29 @@
== column_definition
:description: Sets the column name, defines the data type, and optionally sets a column to static or counter.
Enclosed in parentheses after the table name, use a comma-separated list to define multiple columns.
All tables must have at least one https://cassandra.apache.org/_/glossary.html#primary-key[primary key] column.
Each column is defined using the following syntax: `+column_name cql_type_definition [STATIC | PRIMARY KEY] [, ...]+`
*Restriction:*
* A table must have at least one `PRIMARY KEY`.
* When `PRIMARY KEY` is at the end of a column definition, that column is the only primary key for the table, and is defined as the https://cassandra.apache.org/_/glossary.html#[partition-key][partition key].
* A static column cannot be a primary key.
* Primary keys can include frozen collections.
*column_name* ::
Use a unique name for each column in a table.
To preserve case or use special characters, enclose the name in double-quotes.
cql_type_definition ::
Defines the type of data allowed in the column.
See xref:reference:data-types.adoc[CQL data type] or a xref:reference:user-defined-type.adoc[user-defined type].
*STATIC* ::
Optional, the column has a single value.
*PRIMARY KEY* ::
When the `PRIMARY KEY` is one column, append PRIMARY KEY to the end of the column definition.
This is only schema information required to create a table.
When there is one primary key, it is the partition key;
the data is divided and stored by the unique values in this column: ``column_name cql_type_definition PRIMARY KEY``.
+
Alternatively, you can declare the primary key consisting of only one column in the same way as you declare a compound primary key.

10
doc/modules/cassandra/partials/single-partition-batch-note.adoc Normal file
View File

@ -0,0 +1,10 @@
[NOTE]
====
If there are two different tables in the same keyspace and the two tables have the same partition key, this scenario is considered a single partition batch.
There will be a single mutation for each table.
This happens because the two tables could have different columns, even though the keyspace and partition are the same.
Batches allow a caller to bundle multiple operations into a single batch request.
All the operations are performed by the same coordinator.
The best use of a batch request is for a single partition in multiple tables in the same keyspace.
Also, batches provide a guarantee that mutations will be applied in a particular order.
====

29
doc/modules/cassandra/partials/table-column-definitions.adoc Normal file
View File

@ -0,0 +1,29 @@
== column_definition
:description: Sets the column name, defines the data type, and optionally sets a column to static or counter.
Enclosed in parentheses after the table name, use a comma-separated list to define multiple columns.
All tables must have at least one https://cassandra.apache.org/_/glossary.html#primary-key[primary key] column.
Each column is defined using the following syntax: `+column_name cql_type_definition [STATIC | PRIMARY KEY] [, ...]+`
*Restriction:*
* A table must have at least one `PRIMARY KEY`.
* When `PRIMARY KEY` is at the end of a column definition, that column is the only primary key for the table, and is defined as the https://cassandra.apache.org/_/glossary.html#[partition-key][partition key].
* A static column cannot be a primary key.
* Primary keys can include frozen collections.
*column_name* ::
Use a unique name for each column in a table.
To preserve case or use special characters, enclose the name in double-quotes.
cql_type_definition ::
Defines the type of data allowed in the column.
See xref:reference:data-types.adoc[CQL data type] or a xref:reference:user-defined-type.adoc[user-defined type].
*STATIC* ::
Optional, the column has a single value.
*PRIMARY KEY* ::
When the `PRIMARY KEY` is one column, append PRIMARY KEY to the end of the column definition.
This is only schema information required to create a table.
When there is one primary key, it is the partition key;
the data is divided and stored by the unique values in this column: ``column_name cql_type_definition PRIMARY KEY``.
+
Alternatively, you can declare the primary key consisting of only one column in the same way as you declare a compound primary key.

146
doc/modules/cassandra/partials/table-properties.adoc Normal file
View File

@ -0,0 +1,146 @@
[[table_options]]
== table_options
:description: CQL table properties and descriptions of the syntax.
Tunes data handling, including I/O operations, compression, and compaction.
Table property options use the following syntax:
* Single values: `<option_name> = '<value>'`
* Multiple values: `+<option_name> = { '<subproperty>' : '<value>' [, ...] } [AND ...]+`
+
Simple JSON format, key-value pairs in a comma-separated list enclosed by curly brackets.
[NOTE]
====
When no value is specified, the default is used.
====
In a CREATE TABLE (or ALTER TABLE) CQL statement, use a `WITH` clause to define table property options.
Separate multiple values with `AND`.
[source,language-cql]
----
CREATE TABLE [<keyspace_name>.]<table_name>
WITH option_name = '<value>'
AND option_name = {<option_map>};
----
*bloom_filter_fp_chance = <N>* ::
False-positive probability for SSTable https://en.wikipedia.org/wiki/Bloom_filter[bloom filter].
When a client requests data, the bloom filter checks if the row exists before executing disk I/O.
Values range from 0 to 1.0, where: `0` is the minimum value use to enable the largest possible bloom filter (uses the most memory) and `1.0` is the maximum value disabling the bloom filter.
[TIP]
====
Recommended setting: `0.1`.
A higher value yields diminishing returns.
====
*Default*: `bloom_filter_fp_chance = '0.01'`
*caching = { 'keys' : 'value', 'rows_per_partition' : 'value'}* ::
Optimizes the use of cache memory without manual tuning.
Weighs the cached data by size and access frequency.
Coordinate this setting with the global caching properties in the cassandra.yaml file.
Valid values:
* `ALL`-- all primary keys or rows
* `NONE`-- no primary keys or rows
* `<N>`: (rows per partition only) -- specify a whole number *Default*: `{ 'keys': 'ALL', 'rows_per_partition': 'NONE' }`
*cdc* ::
Creates a Change Data Capture (CDC) log on the table.
+
Valid values:
* `TRUE`- create CDC log
* `FALSE`- do not create CDC log
*comments = 'some text that describes the table'* ::
Provide documentation on the table.
[TIP]
====
Enter a description of the types of queries the table was designed to satisfy.
====
[[DefaultTTL]]*default_time_to_live* ::
TTL (Time To Live) in seconds, where zero is disabled.
The maximum configurable value is `630720000` (20 years).
Beginning in 2018, the expiration timestamp can exceed the maximum value supported by the storage engine;
see the warning below.
If the value is greater than zero, TTL is enabled for the entire table and an expiration timestamp is added to each column.
A new TTL timestamp is calculated each time the data is updated and the row is removed after all the data expires.
+
Default value: `0` (disabled).
+
[WARNING]
====
The database storage engine can only encode TTL timestamps through `January 19 2038 03:14:07 UTC` due to the https://en.wikipedia.org/wiki/Year_2038_problem[Year 2038 problem].
The TTL date overflow policy determines whether requests with expiration timestamps later than the maximum date are rejected or inserted.
====
[[gc_grace_seconds]]*gc_grace_seconds* ::
Seconds after data is marked with a tombstone (deletion marker) before it is eligible for garbage-collection.
Default value: 864000 (10 days).
The default value allows time for the database to maximize consistency prior to deletion.
+
[NOTE]
====
Tombstoned records within the grace period are excluded from xref:managing/operating/hints.adoc[hints] or xref:developing/cql/ddl.adoc#batch_statement[batched mutations].
====
+
In a single-node cluster, this property can safely be set to zero.
You can also reduce this value for tables whose data is not explicitly deleted -- for example, tables containing only data with https://cassandra.apache.org/_/glossary.html#gloss_ttl[TTL] set, or tables with `default_time_to_live` set.
However, if you lower the `gc_grace_seconds` value, consider its interaction with these operations:
+
* *hint replays*: When a node goes down and then comes back up, other nodes replay the write operations (called xref:managing/operating/hints.adoc[hints]) that are queued for that node while it was unresponsive.
The database does not replay hints older than gc_grace_seconds after creation.
The xref:managing/configuration/configuration/cass_yaml_file.adoc#max_hint_window[max_hint_window] setting in the
xref:managing/configuration/configuration/cass_yaml_file.adoc[cassandra.yaml] file sets the time limit (3 hours by default) for collecting hints for the unresponsive node.
* *batch replays*: Like hint queues, xref:developing/cql/ddl.adoc#batch_statement[batch operations] store database mutations that are replayed in sequence.
As with hints, the database does not replay a batched mutation older than gc_grace_seconds after creation.
If your application uses batch operations, consider the possibility that decreasing gc_grace_seconds increases the chance that a batched write operation may restore deleted data.
The configuration/cass_yaml_file.html#batchlog_replay_throttle[batchlog_replay_throttle] property in the cassandra.yaml file give some control of the batch replay process.
The most important factors, however, are the size and scope of the batches you use.
*memtable_flush_period_in_ms* ::
Milliseconds before `memtables` associated with the table are flushed.
When memtable_flush_period_in_ms=0, the memtable will flush when:
* the flush threshold is met
* on shutdown
* on nodetool flush
* when commitlogs get full *Default*: `0`
*min_index_interval* ::
Minimum gap between index entries in the index summary.
A lower min_index_interval means the index summary contains more entries from the index, which allows the database to search fewer index entries to execute a read.
A larger index summary may also use more memory.
The value for min_index_interval is the densest possible sampling of the index.
*max_index_interval* ::
If the total memory usage of all index summaries reaches this value,
{product} decreases the index summaries for the coldest SSTables to the maximum set by max_index_interval.
The max_index_interval is the sparsest possible sampling in relation to memory pressure.
*speculative_retry* ::
Configures https://www.datastax.com/dev/blog/rapid-read-protection-in-cassandra-2-0-2[rapid read protection].
Normal read requests are sent to just enough replica nodes to satisfy the https://cassandra.apache.org/_/glossary.html#gloss_consistency_level[consistency level].
In rapid read protection, extra read requests are sent to other replicas, even after the consistency level has been met.
The speculative retry property specifies the trigger for these extra read requests.
+
* ALWAYS: The coordinator node sends extra read requests to all other replicas after every read of that table.
* <X>percentile: Track each table's typical read latency (in milliseconds).
Coordinator node retrieves the typical latency time of the table being read and calculates X percent of that figure.
The coordinator sends redundant read requests if the number of milliseconds it waits without responses exceeds that calculated figure.
+
For example, if the speculative_retry property for Table_A is set to `80percentile`, and that table's typical latency is 60 milliseconds, the coordinator node handling a read of Table_A would send a normal read request first, and send out redundant read requests if it received no responses within 48ms, which is 80% of 60ms.
+
* <N>ms: The coordinator node sends extra read requests to all other replicas if the coordinator node has not received any responses within `N` milliseconds.
* NONE: The coordinator node does not send extra read requests after any read of that table.
include::partial$compaction-strategies.adoc[]