SELECT

データの場所の特定とクラスター化カラムによるフィルター

partition_conditions

データベースでは、セカンダリ・インデックスまたは検索インデックスをクエリーする場合を除き、すべてのパーティションを制限する必要があります。次の演算子でパーティション・キー・カラムを特定するロジック文を使用します。

• 等号（=）：パーティション・キー・カラム。
• IN：複数のパーティションを検索するには、パーティション・キーの最後のカラムに制限します。
• トークンの範囲（>=、<=、>、および<）：パーティション・キーを完全にトークン化します（token関数の引数として順番に指定されたすべてのパーティション・キー・カラム）。トークン範囲を使用して特定のノードに格納したデータをスキャンします。

注: セカンダリ・インデックス・クエリーでは、パーティション・キー・ロジック文で使用できる演算子は等価のみです。

例と手順については、「パーティション・キー」を参照してください。

clustering_conditions

クラスター化セグメントを特定するロジック文を使用します。クラスター化カラムは、複数のクラスター化カラムがある場合はネストされる、格納データのソート順を設定します。パーティション・キーの評価後、データベースは、1番目（最上位）、2番目、3番目などネストされた順序でクラスター化した文を評価します。

テーブルにクラスター化カラムが1つしかない場合、ロジック文ではすべての演算子がサポートされます。テーブルに複数のクラスター化カラムがある場合にテーブルのパーティション内のデータを効率よく見つけるには、次の制限を適用します。

• 最後のクラスター化カラムを除くすべてのクラスター化カラム：
  • 等号（=）
  • IN
• 最後のクラスター化カラム：すべての等価演算子、非等価演算子、および複数のカラムの比較

クラスター化カラムのロジック文では、複数のクラスター化セグメントに及ぶスライスを返すこともできます。

( column1, column2, ... ) operator ( value1, value2, ... )
[ AND ( column1, column2, ... ) operator ( value1, value2, ... ) ]

スライスを使用すると、対応する値のある行を特定し、その前、後および間にあるすべての行を返すことができます（2つのスライス文が含まれている場合）。

例と手順については、「クラスター化カラム」を参照してください。

カラム別名の使用

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;

 best_rank | cyclist_name
-----------+---------------
         1 | Daniel MARTIN

(1 rows)

FROMを使用したソース・テーブルの指定

次のSELECT文の例では、rank_by_year_and_nameテーブルの行数が返されます。

SELECT COUNT(*)
FROM cycling.rank_by_year_and_name;

LIMITを使用した、返される行数の制御

LIMITオプションは、クエリーが返す最大行数を設定します。

SELECT lastname 
FROM cycling.cyclist_name 
LIMIT 50000;

たとえば、クエリーが105,291行と一致しても、データベースは最初の50,000行のみを返します。

cqlshシェルのデフォルトの行数は10,000に制限されています。DSEサーバーとネイティブ・プロトコルでは、返される行の数は制限されませんが、誤った形式のクエリーによってシステムが不安定になるのを防ぐためにタイムアウトが適用されます。

パーティションの選択

WHERE partition_column = value

WHERE partition_column IN ( value1, value2 [ ,... ] )

WHERE partition_column1 = value1 
AND partition_column2 = value2 [ AND ... ] )

PER PARTITION LIMITを使用した、返される行数の制御

PER PARTITION LIMITオプションを使用して、クエリーで各パーティションから返される行数の最大数を設定します。

たとえば、cyclingキースペースには次のテーブルが含まれます。

CREATE TABLE cycling.rank_by_year_and_name (
  race_year int,
  race_name text,
  cyclist_name text,
  rank int,
  PRIMARY KEY ((race_year, race_name), rank)
);

このテーブルには次の行が含まれます。

 race_year | race_name                                  | rank | cyclist_name
-----------+--------------------------------------------+------+----------------------
      2014 |                        4th Tour of Beijing |    1 |    Phillippe GILBERT
      2014 |                        4th Tour of Beijing |    2 |        Daniel MARTIN
      2014 |                        4th Tour of Beijing |    3 | Johan Esteban CHAVES
      2014 | Tour of Japan - Stage 4 - Minami > Shinshu |    1 |        Daniel MARTIN
      2014 | Tour of Japan - Stage 4 - Minami > Shinshu |    2 | Johan Esteban CHAVES
      2014 | Tour of Japan - Stage 4 - Minami > Shinshu |    3 |      Benjamin PRADES
      2015 |   Giro d'Italia - Stage 11 - Forli > Imola |    1 |        Ilnur ZAKARIN
      2015 |   Giro d'Italia - Stage 11 - Forli > Imola |    2 |      Carlos BETANCUR
      2015 | Tour of Japan - Stage 4 - Minami > Shinshu |    1 |      Benjamin PRADES
      2015 | Tour of Japan - Stage 4 - Minami > Shinshu |    2 |          Adam PHELAN
      2015 | Tour of Japan - Stage 4 - Minami > Shinshu |    3 |         Thomas LEBAS

(11 rows)

このクエリーは、PER PARTITION LIMIT 2を使用して、レース年とレース名の組み合わせごとに上位2名のレーサーを返します。

SELECT * 
FROM cycling.rank_by_year_and_name 
PER PARTITION LIMIT 2;

出力：

 race_year | race_name                                  | rank | cyclist_name
-----------+--------------------------------------------+------+----------------------
      2014 |                        4th Tour of Beijing |    1 |    Phillippe GILBERT
      2014 |                        4th Tour of Beijing |    2 |        Daniel MARTIN
      2014 | Tour of Japan - Stage 4 - Minami > Shinshu |    1 |        Daniel MARTIN
      2014 | Tour of Japan - Stage 4 - Minami > Shinshu |    2 | Johan Esteban CHAVES
      2015 |   Giro d'Italia - Stage 11 - Forli > Imola |    1 |        Ilnur ZAKARIN
      2015 |   Giro d'Italia - Stage 11 - Forli > Imola |    2 |      Carlos BETANCUR
      2015 | Tour of Japan - Stage 4 - Minami > Shinshu |    1 |      Benjamin PRADES
      2015 | Tour of Japan - Stage 4 - Minami > Shinshu |    2 |          Adam PHELAN

(8 rows)

WHEREを使用したデータのフィルター

WHERE句には、SELECTで返された行をフィルター処理する1つまたは複数の関係が含まれます。

カラムの仕様

パーティション・キーでのフィルター

CREATE TABLE cycling.cyclist_career_teams (
  id UUID PRIMARY KEY,
  lastname text,
  teams set<text>
);

SELECT id, lastname, teams 
FROM cycling.cyclist_career_teams 
WHERE id = 5b6962dd-3f90-4c93-8f61-eabfa4a803e2;

この例のテーブルには、より複雑なプライマリ・キーが含まれています。

CREATE TABLE cycling.events (
  year int,
  start_month int,
  start_day int,
  end_month int,
  end_day int,
  race text,
  discipline text,
  location text,
  uci_code text,
  PRIMARY KEY (
    (year, discipline), start_month, start_day, race
  )
);

SELECT *
FROM cycling.events
WHERE year = 2017
  AND discipline = 'Cyclo-cross'
  AND start_month = 1
  AND start_day = 1;

出力：

 year | discipline  | start_month | start_day | race                                   | end_day | end_month | location | uci_code
------+-------------+-------------+-----------+----------------------------------------+---------+-----------+----------+----------
 2017 | Cyclo-cross |           1 |         1 | DVV verzekeringen trofee - GP Sven Nys |    null |      null |     Baal |      C1 

(1 rows)

クラスター化カラムでのフィルター

パーティション・キーのすべての要素を参照する関係がその前にある場合のみ、クラスター化カラムに対して関係を使用します。

cyclingキースペースのテーブル例（パーティション・キーはidカラム、クラスター化カラムはrace_points）：

CREATE TABLE cycling.cyclist_points (
  id UUID, 
  race_points int, 
  firstname text, 
  lastname text, 
  race_title text, 
  PRIMARY KEY (id, race_points)
);

クエリーの例：

SELECT SUM(race_points) 
FROM cycling.cyclist_points 
WHERE id = e3b19ec4-774a-4d1c-9e5a-decec1e30aac
  AND race_points > 7;

出力：

 system.sum(race_points)
-------------------------
                     195

(1 rows)

CREATE TABLE cycling.calendar (
  race_id int,
  race_name text,
  race_start_date timestamp,
  race_end_date timestamp,
  PRIMARY KEY (
    race_id, race_start_date, race_end_date
  )
) WITH CLUSTERING ORDER BY (
  race_start_date DESC, race_end_date DESC
);

SELECT * 
FROM cycling.calendar 
WHERE race_start_date = '2015-06-13' 
ALLOW FILTERING; 

出力：

 race_id | race_start_date                 | race_end_date                   | race_name
---------+---------------------------------+---------------------------------+----------------
     102 | 2015-06-13 00:00:00.000000+0000 | 2015-06-21 00:00:00.000000+0000 | Tour de Suisse

(1 rows)

インデックス付きカラムでのフィルター

セカンダリ・インデックス付きのカラムがあるテーブルのSELECTのWHERE句には、インデックス付きカラムに対する等価関係を少なくとも1つ含める必要があります。「カラムのインデックスの作成」を参照してください。

IN演算子の使用

等価条件演算子であるINは、WHERE句内の複数のカラム値をリストするために使用します。

この例では、値のリストにrace_idがある行を選択します。

SELECT * 
FROM cycling.calendar 
WHERE race_id IN (101, 102, 103); 

リスト内の値はカンマで区切られます。

INを使用した複合プライマリ・キーでのフィルター処理

その前にプライマリ・キーのそれ以前のすべてのカラムに対して等価条件がある場合のみ、複合プライマリ・キーの最後のカラムでIN条件を使用します。

CREATE TABLE cycling.cyclist_id (
  lastname text,
  firstname text,
  age int,
  id UUID,
  PRIMARY KEY ((lastname, firstname), age)
);

このクエリーには、プライマリ・キーの最初の2つのカラムの等価条件と、プライマリ・キーの最後のカラムのIN条件を含む適切なWHERE句が記述されています。

SELECT * 
FROM cycling.cyclist_id 
WHERE lastname = 'EENKHOORN'
  AND firstname = 'Pascal'
  AND age IN (17, 18); 

INを使用する場合、最後のクラスター化カラム以外のクラスター化カラムに対する等価テストを省略できます。これにはALLOW FILTERINGが必要になることがあるため、プロダクション環境では使用しないでください。

CREATE TABLE cycling.events (
  year int,
  start_month int,
  start_day int,
  end_month int,
  end_day int,
  race text,
  discipline text,
  location text,
  uci_code text,
  PRIMARY KEY (
    (year, discipline), start_month, start_day, race
  )
);

SELECT *
FROM cycling.events
WHERE race = 'Superprestige - Hoogstraten -2017'
  AND start_month IN (1, 2)
ALLOW FILTERING;

CQLでは、IN句内に値の空のリストを使用できるため、ドライバー・アプリケーションで空の配列を引数としてIN句に渡す場合に役立ちます。「Connecting to DSE clusters using DSE drivers」を参照してください。

INを使用すべきでない場合

通常、パーティション・キーの関係にINを使用することは推奨されません。値のリストを処理するには、SELECTで多数のノードをクエリーする必要がある場合があり、それによってパフォーマンスが低下します。

たとえば、ノードが30、レプリケーション係数が3、整合性レベルがLOCAL_QUORUMの1つのローカル・データ・センター・クラスターがあるとします。パーティション・キーを1つ指定したクエリーは2つのノードに送られます。しかし、SELECTでIN条件が使用されている場合、キーがトークン範囲のどこに位置するかにより、演算には最大で20のノードが含まれる可能性があります。

クラスター化カラムにINを使用すると、すべてのクエリー・アクションが1つのパーティションで実行されるため、パフォーマンスのレイテンシーが低下します。

「Cassandra Query Patterns: Not using the “in” query for multiple partitions」を参照してください。

コレクションでのフィルター

クエリーによりコレクション全体を取得できます。また、コレクション・カラムを対象としてインデックスを作成してから、WHERE句にCONTAINS条件を指定してコレクションに属する特定の値のデータをフィルター処理することも、CONTAINS KEYを使用してキーでフィルター処理することもできます。

この例は、cyclist_career_teamsテーブルのteamsという名前のテキスト値のセットを示しています。このクエリーは、teamsセット内の値でフィルター処理します。

SELECT *
FROM cycling.cyclist_career_teams
WHERE teams CONTAINS 'Rabobank-Liv Giant';

 id                                   | lastname | teams
--------------------------------------+----------+----------------------------------------------------------------------------------------------------
 1c9ebc13-1eab-4ad5-be87-dce433216d40 |    BRAND | {'AA Drink - Leontien.nl', 'Leontien.nl', 'Rabobank-Liv Giant', 'Rabobank-Liv Woman Cycling Team'}

(1 rows)

CREATE INDEX team_year_idx
ON cycling.cyclist_teams ( KEYS (teams) );

SELECT *
FROM cycling.cyclist_teams
WHERE teams CONTAINS KEY 2015;

「コレクションのインデックス作成」および「cqlCreateIndex.html#cqlCreateIndex__CreatIdxCollKey」を参照してください。

マップのエントリーのフィルター

CREATE INDEX blist_idx
ON cycling.birthday_list ( ENTRIES(blist) );

SELECT *
FROM cycling.birthday_list
WHERE blist['age'] = '23';

frozenのフル・コレクションのフィルター

CREATE INDEX rnumbers_idx
ON cycling.race_starts ( FULL(rnumbers) );

SELECT *
FROM cycling.race_starts
WHERE rnumbers = [39, 7, 14];

範囲関係

DataStax Enterpriseでは、&gt;または&lt;比較をサポートしています。しかし、指定されたパーティション・キーの場合、clustering columnに対する条件は、連続した行のセットを選択できるフィルターに制限されます。

SELECT * 
FROM cycling.calendar 
WHERE race_id = 101
  AND race_start_date >= '2014-05-27' 
  AND race_start_date < '2017-06-16';

 race_id | race_start_date                 | race_end_date                   | race_name
---------+---------------------------------+---------------------------------+-----------------------
     101 | 2015-06-07 00:00:00.000000+0000 | 2015-06-14 00:00:00.000000+0000 | Criterium du Dauphine
     101 | 2014-06-06 00:00:00.000000+0000 | 2014-06-13 00:00:00.000000+0000 | Criterium du Dauphine

(2 rows)

連続した行のセットを選択できるようにするには、WHERE句でプライマリ・キーのrace_idコンポーネントに等価条件を適用する必要があります。

複合プライマリ・キーの使用と結果のソート

SELECT *
FROM cycling.cyclist_category
WHERE category = 'Time-trial'
ORDER BY points DESC;

出力：

 category   | points | id                                   | lastname
------------+--------+--------------------------------------+------------
 Time-trial |    182 | 220844bf-4860-49d6-9a4b-6b5d3a79cbfb |  TIRALONGO
 Time-trial |      3 | 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47 | KRUIJSWIJK

(2 rows)

CREATE TABLE cycling.events (
  year int,
  start_month int,
  start_day int,
  end_month int,
  end_day int,
  race text,
  discipline text,
  location text,
  uci_code text,
  PRIMARY KEY (
    (year, discipline), start_month, start_day, race
  )
);

このクエリーには、raceカラムの前にあるすべてのプライマリ・キー・カラムの値を指定し、raceによって結果を順序指定するWHERE句が含まれています。

SELECT *
FROM cycling.events
WHERE year = 2017
  AND discipline = 'Cyclo-cross'
  AND start_month = 1
  AND start_day = 1
ORDER BY race;

出力：

 year | discipline  | start_month | start_day | race                                   | end_day | end_month | location | uci_code
------+-------------+-------------+-----------+----------------------------------------+---------+-----------+----------+----------
 2017 | Cyclo-cross |           1 |         1 | DVV verzekeringen trofee - GP Sven Nys |    null |      null |     Baal |      C1 

(1 rows)

SELECT *
FROM cycling.events
WHERE year = 2017
  AND discipline = 'Cyclo-cross'
  AND start_month = 1
ORDER BY start_day, race;

結果のグループ化

GROUP BY句は、カラムのセットについて同じ値を共有する選択した行を1つのグループにまとめます。GROUP BY句には、次のものを含めることができます。

• パーティション・キーのカラムとクラスター化カラム。
• GROUP BY句で指定された最後のクラスター化カラムでのユーザー定義関数（UDF）を含む、決定論的単調関数。継続時間パラメーターと開始時間パラメーターが定数の場合、FLOOR()関数は単調関数です。
• 決定性集計。

CREATE TABLE cycling.race_times_summary (
  race_date date,
  race_time time,
  PRIMARY KEY (race_date, race_time)
);

 race_date  | race_time
------------+--------------------
 2019-03-21 | 10:01:18.000000000
 2019-03-21 | 10:15:20.000000000
 2019-03-21 | 11:15:38.000000000
 2019-03-21 | 12:15:40.000000000
 2018-07-26 | 10:01:18.000000000
 2018-07-26 | 10:15:20.000000000
 2018-07-26 | 11:15:38.000000000
 2018-07-26 | 12:15:40.000000000
 2017-04-14 | 10:01:18.000000000
 2017-04-14 | 10:15:20.000000000
 2017-04-14 | 11:15:38.000000000
 2017-04-14 | 12:15:40.000000000

(12 rows)

SELECT
  race_date, race_time 
FROM
  cycling.race_times_summary
GROUP BY
  race_date;

 race_date  | race_time
------------+--------------------
 2019-03-21 | 10:01:18.000000000
 2018-07-26 | 10:01:18.000000000
 2017-04-14 | 10:01:18.000000000

(3 rows)

SELECT
  race_date, FLOOR(race_time, 1h), COUNT(*)
FROM
  cycling.race_times_summary
GROUP BY
  race_date, FLOOR(race_time, 1h);

 race_date  | system.floor(race_time, 1h) | count
------------+-----------------------------+-------
 2019-03-21 |          10:00:00.000000000 |     2
 2019-03-21 |          11:00:00.000000000 |     1
 2019-03-21 |          12:00:00.000000000 |     1
 2018-07-26 |          10:00:00.000000000 |     2
 2018-07-26 |          11:00:00.000000000 |     1
 2018-07-26 |          12:00:00.000000000 |     1
 2017-04-14 |          10:00:00.000000000 |     2
 2017-04-14 |          11:00:00.000000000 |     1
 2017-04-14 |          12:00:00.000000000 |     1

(9 rows)

集計の計算

DSEは、集計値をSELECT文に返す組み込み関数COUNT()、MIN()、MAX()、SUM()、およびAVG()を提供します。ユーザー定義集計（UDA）を作成することもできます。次のセクションでは、例を示します。

COUNT()を使用した、カラムのNULL以外の値のカウントの取得

SELECTでCOUNT(column_name)を使用すると、カラムに含まれるNULL以外の値の数を返します。COUNTはNULL値を無視します。

このクエリーは、cyclist_nameテーブル内の姓の数をカウントします。

SELECT COUNT(lastname)
FROM cycling.cyclist_name;

COUNT()を使用した、条件に一致する行と集計値の取得

SELECTでCOUNT(*)を使用すると、クエリーに一致した行の数を返します。COUNT(1)を使用しても同じ結果を得ることができます。他の集計関数またはカラムと組み合わせてCOUNT(*)またはCOUNT(1)を使用できます。

このクエリーは、cyclist_nameテーブルの行数を返します。

SELECT COUNT(*)
FROM cycling.cyclist_name;

このクエリーは、eventsテーブルの行数をカウントし、start_dayの最大値を計算します。

SELECT start_month, MAX(start_day), COUNT(*)
FROM cycling.events
WHERE year = 2017
  AND discipline = 'Cyclo-cross';

この例は、イベント・テーブルに格納されていない年を示します。

SELECT start_month, MAX(start_day)
FROM cycling.events
WHERE year = 2022
ALLOW FILTERING;

 start_month | system.max(start_day)
-------------+-----------------------
        null |                  null

(1 rows)

カラムの最大値および最小値の取得

SELECTでMAX(column_name)を使用すると、カラム内の最大値を返します。カラムのデータ型が数値（bigint、decimal、double、float、int、またはsmallint）、MAX(column_name)である場合は最大値を返します。

SELECT MAX(race_points) 
FROM cycling.cyclist_points
WHERE id = e3b19ec4-774a-4d1c-9e5a-decec1e30aac;

 system.max(race_points)
-------------------------
                     120

(1 rows)

Warnings :
Aggregation query used without partition key

 system.min(race_points)
-------------------------
                       6

(1 rows)

MAXまたはMIN関数が参照するカラムがasciiデータ型またはtextデータ型の場合、これらの関数はアルファベット順にソートしたカラム値の最後または最初の項目を返します。指定したカラムのデータ型がdate型またはtimestamp型の場合、これらの関数は最も新しいまたは最も古い日時を返します。

カラムにNULL値がある場合、MAXとMINはNULL値を無視します。行のセット全体のカラムにNULLが含まれている場合、MAXおよびMINはNULLを返します。

クエリーにWHERE句（推奨）が含まれている場合、MAXはWHERE条件を満たす行から最大値を返し、MINはWHERE条件を満たす行から最小値を返します。

数値のカラムの平均または合計の取得

この例では、AVGを使用してカラム内のすべての値の平均を計算します。

SELECT AVG(race_points) 
FROM cycling.cyclist_points
WHERE id = e3b19ec4-774a-4d1c-9e5a-decec1e30aac;

 system.avg(race_points)
-------------------------
                      67

(1 rows)

SUMを使用して合計を取得します。

SELECT SUM(race_points) 
FROM cycling.cyclist_points 
WHERE id = e3b19ec4-774a-4d1c-9e5a-decec1e30aac
  AND race_points > 7;

 system.sum(race_points)
-------------------------
                     195

(1 rows)

返された行にAVG関数で参照されるカラムのNULL値が含まれている場合、その行は行数に含まれますが、平均の計算にはNULL値の代わりに0値が使用されます。SUM関数とAVG関数はtext型、uuid型またはdate型のフィールドには使用できません。

このクエリーは、ユーザー定義集計（UDA）を使用してサイクリスト・チームの平均タイムを返します。

SELECT cycling.average(cyclist_time_sec)
FROM cycling.team_average 
WHERE team_name = 'UnitedHealthCare Pro Cycling Womens Team' 
  AND race_title = 'Amgen Tour of California Women''s Race presented by SRAM - Stage 1 - Lake Tahoe > Lake Tahoe';

書き込みが発生した日時の取得

カラムにWRITETIME関数が適用されると、カラムがデータベースに書き込まれた日時がマイクロ秒単位で返されます。

このクエリーは、cyclistのfirstnameカラムに書き込みが行われた日時を取得します。

SELECT WRITETIME (firstname)
FROM cycling.cyclist_points
WHERE id = e3b19ec4-774a-4d1c-9e5a-decec1e30aac;

 writetime(firstname)
----------------------
     1538688876521481
     1538688876523973
     1538688876525239

マイクロ秒単位の最終書き込み日時「1538688876525239」のWRITETIME出力を変換すると、「Thursday, October 4, 2018 4:34:36.525 PM GMT-05:00 DST」になります。

カラムのTime To Liveの取得

カラム値のTime To Live（TTL）値は、値にトゥームストーンのマークが付くまでの秒数です。

INSERT INTO cycling.calendar (
  race_id, race_name, race_start_date, race_end_date
) VALUES (
  200, 'placeholder', '2015-05-27', '2015-05-27'
)
USING TTL 200;

この例では、UPDATEを使用して1つのrace_nameカラム値のTTLを200秒に設定します。

UPDATE cycling.calendar 
USING TTL 300 
SET race_name = 'dummy' 
WHERE race_id = 200 
  AND race_start_date = '2015-05-27' 
  AND race_end_date = '2015-05-27';

SELECT TTL(race_name) 
FROM cycling.calendar 
WHERE race_id = 200;

 ttl(race_name)
----------------
            276

(1 rows)

JSON形式の値の取得