CQLクイック・リファレンス

クイック・リファレンスとしてCassandraクエリー言語(CQL)コマンドの統合された構文リストを示します。

クイック・リファレンスとしてCassandraクエリー言語(CQL)コマンドの統合された構文リストを示します。

他のCQLバージョン(5.1 | 6.0 | DDAC)についても、このクイック・リファレンス・ガイドを参照してください。

ALTER KEYSPACE

ALTER KEYSPACE keyspace_name 
  WITH REPLICATION = { replication_map }
  [ AND DURABLE_WRITES = ( true | false ) ] ;
詳細情報

1つのデータ・センター内でcyclingキースペースをNetworkTopologyStrategyに変更し、永続書き込みを無効にします(このような使用法は推奨されていません)。この例では、レプリケーション係数を1としてデフォルトのデータ・センター名を使用します。

ALTER KEYSPACE cycling
WITH REPLICATION = { 
  'class' : 'NetworkTopologyStrategy',
  'SearchAnalytics' : 1 } 
 AND DURABLE_WRITES = false ;

ALTER MATERIALIZED VIEW

ALTER MATERIALIZED VIEW [keyspace_name.]view_name 
  WITH table_options [ AND table_options ... ] ;
詳細情報

このセクションでは、cyclist_baseおよびcyclist_by_age-mvを使用します。

テーブル・プロパティの変更

コマンドを追加して、ブルーム・フィルターのプロパティを設定します。

ALTER MATERIALIZED VIEW cycling.cyclist_by_age 
WITH comment = 'A most excellent and useful view'
AND bloom_filter_fp_chance = 0.02;

マテリアライズド・ビューに適用されるプロパティの概要については、「table_options」を参照してください。

圧縮とコンパクションの変更

プロパティ・マップを使用して、圧縮またはコンパクションの新しいプロパティを指定します。
ALTER MATERIALIZED VIEW cycling.cyclist_by_age 
WITH compression = { 
  'sstable_compression' : 'DeflateCompressor', 
  'chunk_length_kb' : 64 }
AND compaction = {
  'class': 'SizeTieredCompactionStrategy', 
  'max_threshold': 64};

キャッシングの変更

プロパティ・マップを使用して、キャッシング・プロパティを作成および変更できます。

この例では、keysプロパティをNONE(デフォルトはALL)に変更し、rows_per_partitionプロパティを15に変更します。
ALTER MATERIALIZED VIEW cycling.cyclist_by_age 
WITH caching = { 
  'keys' : 'NONE', 
  'rows_per_partition' : '15' };

現在のマテリアライズド・ビューのプロパティの表示

DESCRIBE MATERIALIZED VIEWを使用すると、現在のプロパティがすべて表示されます。
DESCRIBE MATERIALIZED VIEW cycling.cyclist_by_age
実行可能なCQLスクリプトが表示されます。
CREATE MATERIALIZED VIEW cycling.cyclist_by_age AS
    SELECT age, cid, birthday, country, name
    FROM cycling.cyclist_base
    WHERE age IS NOT NULL AND cid IS NOT NULL
    PRIMARY KEY (age, cid)
    WITH CLUSTERING ORDER BY (cid ASC)
    AND bloom_filter_fp_chance = 0.02
    AND caching = {'keys': 'NONE', 'rows_per_partition': '15'}
    AND comment = 'A most excellent and useful view'
    AND compaction = {'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold': '64', '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';

ALTER ROLE

ALTER ROLE role_name 
  [ WITH [ PASSWORD = role_password ] 
  [ [ AND ] LOGIN = ( true | false ) ] 
  [ [ AND ] SUPERUSER = ( true | false ) ] 
  [ [ AND ] OPTIONS = { option_map } ] ] ;
詳細情報

coachロールのパスワードを変更します。
ALTER ROLE sandy WITH PASSWORD='bestTeam';

ALTER SEARCH INDEX CONFIG

ALTER SEARCH INDEX CONFIG ON [keyspace_name.]table_name
  ( ADD element_path [ attribute_list ] WITH $$ json_map $$
  | SET element_identifier = 'value'
  | SET shortcut = value
  | DROP element_identifier
  | DROP shortcut ) ;
詳細情報

wiki.solrキースペースとテーブル、および指定したオプションについて検索インデックス構成を変更します。

検索インデックスの暗号化を有効にする

検索インデックスの暗号化を有効にします。
  1. 構成スキーマを変更します。
    ALTER SEARCH INDEX CONFIG ON cycling.comments 
    SET directoryFactory = 'encrypted';
  2. 保留中のスキーマでこの変更が適切であることを確認します。
    DESC PENDING SEARCH INDEX CONFIG ON cycling.comments
  3. 構成をアクティブにします。
    <?xml version="1.0" encoding="UTF-8" standalone="no"?>
    <config>
      <luceneMatchVersion>LUCENE_6_0_1</luceneMatchVersion>
      <dseTypeMappingVersion>2</dseTypeMappingVersion>
      <directoryFactory class="solr.EncryptedFSDirectoryFactory" name="DirectoryFactory"/>
      <indexConfig>
        <rt>false</rt>
      </indexConfig>
      <jmx/>
      <updateHandler>
        <autoSoftCommit>
          <maxTime>10000</maxTime>
        </autoSoftCommit>
      </updateHandler>
      <query>
        <filterCache class="solr.SolrFilterCache" highWaterMarkMB="2048" lowWaterMarkMB="1024"/>
        <enableLazyFieldLoading>true</enableLazyFieldLoading>
        <useColdSearcher>true</useColdSearcher>
        <maxWarmingSearchers>16</maxWarmingSearchers>
      </query>
      <requestDispatcher>
        <requestParsers enableRemoteStreaming="true" multipartUploadLimitInKB="2048000"/>
        <httpCaching never304="true"/>
      </requestDispatcher>
      <requestHandler class="solr.SearchHandler" default="true" name="search"/>
      <requestHandler class="com.datastax.bdp.search.solr.handler.component.CqlSearchHandler" name="solr_query"/>
      <requestHandler class="solr.UpdateRequestHandler" name="/update"/>
      <requestHandler class="solr.UpdateRequestHandler" name="/update/csv" startup="lazy"/>
      <requestHandler class="solr.UpdateRequestHandler" name="/update/json" startup="lazy"/>
      <requestHandler class="solr.FieldAnalysisRequestHandler" name="/analysis/field" startup="lazy"/>
      <requestHandler class="solr.DocumentAnalysisRequestHandler" name="/analysis/document" startup="lazy"/>
      <requestHandler class="solr.admin.AdminHandlers" name="/admin/"/>
      <requestHandler class="solr.PingRequestHandler" name="/admin/ping">
        <lst name="invariants">
          <str name="qt">search</str>
          <str name="q">solrpingquery</str>
        </lst>
        <lst name="defaults">
          <str name="echoParams">all</str>
        </lst>
      </requestHandler>
      <requestHandler class="solr.DumpRequestHandler" name="/debug/dump">
        <lst name="defaults">
          <str name="echoParams">explicit</str>
          <str name="echoHandler">true</str>
        </lst>
      </requestHandler>
    </config>
  4. 構成を適用し、インデックスをリビルドします。
    RELOAD SEARCH INDEX ON cycling.comments;

自動ソフト・コミット時間

自動ソフト・コミットの最大時間を10,000ミリ秒にするように、ショートカットを使用してインデックス構成を設定するには、以下のように入力します。
ALTER SEARCH INDEX CONFIG ON cycling.comments 
SET autoCommitTime = 10000;
保留中の変更をアクティブにします(DESCRIBE SEARCH INDEXを使用して、変更点を確認します)。
RELOAD SEARCH INDEX ON cycling.comments;

要求ハンドラー

構成要求ハンドラーを追加します
ALTER SEARCH INDEX CONFIG ON cycling.comments 
ADD requestHandler[@name='/elevate',@class='solr.SearchHandler', @startup='lazy'] 
WITH  $$ {"defaults":[{"echoParams":"explicit"}],"last-components":["elevator"]} $$;
検索インデックスを読み込みます。
RELOAD SEARCH INDEX ON cycling.comments;
これで、requestHandler要素がconfigに追加されます。
<requestHandler name="/elevate" class="solr.SearchHandler"> 
   <lst name="defaults">
      <str name="echoParams">explicit</int>
   </lst>
   <arr name="last-components">
    <str>elevator</str>
   </arr>
</requestHandler>
deletesを自動的に削除できるようにTieredMergePolicyを拡張するには、以下のように入力します。
ALTER SEARCH INDEX CONFIG ON cycling.comments 
SET indexConfig.mergePolicyFactory[@class='org.apache.solr.index.AutoExpungeDeletesTieredMergePolicyFactory'].bool[@name='mergeSingleSegments'] = true;

ALTER SEARCH INDEX CONFIG ON cycling.comments 
SET indexConfig.mergePolicyFactory[@class='org.apache.solr.index.AutoExpungeDeletesTieredMergePolicyFactory'].int[@name='maxMergedSegmentMB'] = 1005;

ALTER SEARCH INDEX CONFIG ON cycling.comments 
SET indexConfig.mergePolicyFactory[@class='org.apache.solr.index.AutoExpungeDeletesTieredMergePolicyFactory'].int[@name='forceMergeDeletesPctAllowed'] = 25;
検索インデックスを読み込みます。
RELOAD SEARCH INDEX ON cycling.comments;

自動コミット時間の変更

自動コミット時間を変更するには、ALTER SEARCH INDEX CONFIGを使用します。例を次に示します。
ALTER SEARCH INDEX CONFIG ON cycling.comments 
SET autoCommitTime = 1000;

ALTER SEARCH INDEX SCHEMA

ALTER SEARCH INDEX SCHEMA ON [keyspace_name.]table_name
  ( ADD field column_name
  | ADD element_path [ attribute_list ] WITH $$ json_map $$
  | SET element_identifier = 'value'
  | DROP field field_name
  | DROP element_identifier ) ;
詳細情報

wiki.solrキースペースとテーブル、および指定したオプションについて検索インデックス・スキーマを変更します。

要素パスと属性リストを使用して、新しいフィールドを追加する

テーブルに存在しないフィールドをインデックスに追加し、複数のカラムを1つのインデックス付きフィールドに組み合わせて検索することができます。
注: ADD fields.field fieldnameの先頭要素fields.の追加は任意であり、表示上の構造のみを提供します。
ALTER SEARCH INDEX SCHEMA ON cycling.comments 
ADD fields.field[@name='fieldname', @type='StrField', @multiValued = 'false', @indexed='true'];
ALTER SEARCH INDEX SCHEMA
ON cycling.comments
SET types.fieldType[@name='TextField']@class='org.apache.solr.schema.TextField';

ALTER SEARCH INDEX SCHEMA
ON cycling.comments
SET fields.field[@name='comment']@type='TextField';
スキーマの変更を適用するには:
RELOAD SEARCH INDEX ON cycling.comments;

テーブル・カラムをインデックスに追加する

フィールド定義を自動的に作成し、必要に応じて、インデックスがまだ作成されていないフィールドにフィールド型を追加します。
ALTER SEARCH INDEX SCHEMA ON cycling.comments 
ADD FIELD record_id;
スキーマの変更を適用し、インデックスをリビルドするには:
RELOAD SEARCH INDEX ON cycling.comments;

REBUILD SEARCH INDEX ON cycling.comments;

フィールド名の変更

DSEは、カラム名とフィールド名を照合して、CQLカラムを検索インデックス・フィールドにマップします。マップされていないフィールドをコピー・フィールドに使用します。フィールドが存在しない場合は追加されます。
ALTER SEARCH INDEX SCHEMA ON cycling.comments 
SET field[@name='fieldname']@name = 'anotherFieldName';

スキーマの変更を適用するには:

スキーマの変更を適用し、インデックスをリビルドするには:
RELOAD SEARCH INDEX ON cycling.comments;

REBUILD SEARCH INDEX ON cycling.comments;

フィールド型の変更

フィールド型を、スキーマ内で既に定義されている別の型に変更します。
ALTER SEARCH INDEX SCHEMA ON cycling.comments 
SET field[@name='fieldname']@type = 'UUIDField';

スキーマの変更を適用するには:

スキーマの変更を適用し、インデックスをリビルドするには:
RELOAD SEARCH INDEX ON cycling.comments;

REBUILD SEARCH INDEX ON cycling.comments;

フィールドの削除

テーブルではなく、検索インデックスからフィールドを削除します。
ALTER SEARCH INDEX SCHEMA ON cycling.comments 
DROP field anotherFieldName;
スキーマの変更を適用し、インデックスをリビルドするには:
RELOAD SEARCH INDEX ON cycling.comments;

REBUILD SEARCH INDEX ON cycling.comments;

テキスト・フィールドの追加

テキスト・フィールドを追加するには、2つのコマンドが必要です。

ALTER SEARCH INDEX SCHEMA
ON cycling.comments
SET types.fieldType[@name='TextField']@class='org.apache.solr.schema.TextField';

ALTER SEARCH INDEX SCHEMA
ON cycling.comments
SET fields.field[@name='comment']@type='TextField';

ALTER TABLE

ALTER TABLE [keyspace_name.]table_name 
  [ ADD ( column_definition | column_definition_list ) [ , ... ] ]
  [ DROP column_name [ , ... ] ]
  [ RENAME column_name TO column_name ]
  [ WITH table_properties [ , ... ] ] ;
詳細情報

このセクションでは、cyclist_racesテーブルを使用します。

カラムの追加

カラムを追加するには、ADD命令を使用します。
ALTER TABLE cycling.cyclist_races 
  ADD manager UUID;
コレクション型のカラムを追加するには、以下のように記述します。
ALTER TABLE cycling.cyclist_races 
  ADD completed list<text>;

この操作では既存のデータは検証されません。

制約事項: ADD命令を使用して次のカラムを追加することはできません。
  • 既存のカラムと同じ名前のカラム
  • テーブルにクラスター化カラムがない場合の静的カラム。

カラムの削除

テーブルからカラムを除去するには、DROP命令を使用します。
ALTER TABLE cycling.cyclist_races 
  DROP manager;

DROPは、テーブル定義からカラムを削除します。削除されたカラムは、すぐにクエリーできなくなります。カラム・データは次回のコンパクション時に削除されます。削除したカラムの除去をコンパクションの前に強制的に実行するには、ALTER TABLEを使用してメタデータを更新してから、nodetool upgradesstablesを実行して削除を有効にします。

制約事項:
  • カラムを削除して再び追加しても、削除する前にカラムに書き込まれていた値は復元されません。
  • 削除したカラムにクライアントで生成されたタイムスタンプが含まれている場合、そのカラムを再び追加しないでください。書き込み時間機能で生成されたタイムスタンプを含むカラムは再び追加できます。

カラムの名前変更

race_timesテーブのカラムを削除するには:
ALTER TABLE cycling.race_times 
  RENAME race_date TO date;
制約事項: RENAMEには以下の制限事項が適用されます。
  • 変更できるのは、プライマリ・キーのクラスター化カラムの名前のみです。
  • パーティション・キーによってノード上のデータ格納場所が決定するため、パーティション・キーの名前は変更できません。別のパーティション名が必要な場合は、テーブルを再作成し、データを移行する必要があります。
    注: SSTableは不変であるため、RENAMEを使用する場合、多くの制限事項が存在します。ディスクのデータの状態を変更するには、すべてを書き込みなおす必要があります。
  • 名前を変更したカラムのインデックスを作成できます。
  • そのカラムに基づいてインデックスが作成されているカラムの名前は変更できません。
  • 静的なカラムの名前は変更できません。

テーブル・プロパティの変更

既存のテーブルのプロパティを変更するには、ALTER TABLEおよびWITHを使用します。以下の項目を指定できます。
たとえば、WITHを使用してcyclist_baseテーブルにコメントを追加するには、次のように指定します。
ALTER TABLE cycling.cyclist_base
WITH comment = 'basic cyclist information';

テキスト・プロパティ値は単一引用符で囲んでください。

圧縮とコンパクションの変更

commentsテーブルの圧縮またはコンパクションの設定を変更するには、プロパティ・マップを使用します。
ALTER TABLE cycling.comments 
WITH compression = { 
   'sstable_compression' : 'DeflateCompressor', 
   'chunk_length_kb' : 64 };

各キーの名前を単一引用符で囲みます。値が文字列の場合も同様に引用符で囲みます。

注意: 既存のデータを含むテーブルのコンパクション・ストラテジを変更する場合、新しいストラテジを使用して既存のすべてのSSTableが再度書き込まれます。この処理には数時間かかり、プロダクション・システムでは大きな問題となるおそれがあります。この中断を最小限に抑えるためのストラテジについては、「プロダクション・クラスターでコンパクション・ストラテジを変更する方法」および「コンパクション・ストラテジ変更の影響」を参照してください。

キャッシングの変更

commentsテーブルの行キャッシュに格納するパーティションごとの行数を10行に設定します。
ALTER TABLE cycling.comments 
   WITH caching = {
    'keys': 'NONE', 
    'rows_per_partition': 10 };

推測的リトライの変更

cyclist_baseテーブルで、推測的リトライを95パーセンタイルに変更します。
ALTER TABLE cycling.cyclist_base
WITH speculative_retry = '95percentile';
cyclist_baseテーブルで、推測的リトライに10ミリ秒を使用します。
ALTER TABLE cycling.cyclist_base
WITH speculative_retry = '10ms';

バックグラウンド・コンパクションの有効化と無効化

enabledプロパティをfalseプロパティに設定してバックグラウンド・コンパクションを無効にするには、次のように指定します。
ALTER TABLE cycling.comments 
WITH COMPACTION = {
   'class': 'SizeTieredCompactionStrategy', 
   'enabled': 'false' };
警告: バックグラウンド・コンパクションを無効にすると、ディスク領域が回復せず、ゾンビが伝搬する可能性があるため、悪影響が及ぶことがあります。コンパクションはI/Oを消費しますが、ほとんどの場合、コンパクションを有効にしておくことを推奨します。

拡張コンパクション・ログの取得

特定のノードでのコンパクション・アクティビティーに関する詳細な情報を専用のログ・ファイルで収集するには、log_allサブプロパティをtrueに設定します。

重要: 拡張コンパクション・ロギングは、どのノードのどのテーブルに対して有効にした場合も、クラスター内の全ノードの全テーブルで有効になります。

拡張コンパクションを有効にすると、データベースによってcompaction-%d.log%dは連続番号)という名前のファイルがhome/logsに作成されます。

コンパクション・ロギング・サービスでは、次の種類のコンパクション・イベントに関する詳細な情報がログに記録されます。
  • type:enable

    以前にフラッシュされたSSTableをリストします。

    {"type":"enable","keyspace":"test","table":"t","time":1470071098866,"strategies":
      [    {"strategyId":"0","type":"LeveledCompactionStrategy","tables":[],"repaired":true,"folders":
          ["/home/carl/oss/cassandra/bin/../data/data"]},
        {"strategyId":"1","type":"LeveledCompactionStrategy","tables":[],"repaired":false,"folders":
          ["/home/carl/oss/cassandra/bin/../data/data"]
        }
     ]
    }
  • type: flush

    各テーブルのCompactionStrategyも含め、memtableのフラッシュ・イベントをディスク上のSSTableのログに記録します。

    {"type":"flush","keyspace":"test","table":"t","time":1470083335639,"tables":
      [    {"strategyId":"1","table":
          {"generation":1,"version":"mb","size":106846362,"details":
            {"level":0,"min_token":"-9221834874718566760","max_token":"9221396997139245178"}
          }
        }
     ]
    }
  • type: compaction

    コンパクション・イベントをログに記録します。

    {"type":"compaction","keyspace":"test","table":"t","time":1470083660267,
     "start":"1470083660188","end":"1470083660267","input":
      [    {"strategyId":"1","table":
          {"generation":1372,"version":"mb","size":1064979,"details":
            {"level":1,"min_token":"7199305267944662291","max_token":"7323434447996777057"}
          }
        }
     ],"output":
      [    {"strategyId":"1","table":
          {"generation":1404,"version":"mb","size":1064306,"details":
            {"level":2,"min_token":"7199305267944662291","max_token":"7323434447996777057"}
          }
        }
     ]
    }
  • type: pending

    コンパクション・ストラテジの保留中タスクの数をリストします。

    {"type":"pending","keyspace":"test","table":"t",
     "time":1470083447967,"strategyId":"1","pending":200}

テーブル定義の確認

DESCRIBEまたはDESCを使用してテーブル定義を表示します。
DESC cycling.comments
カラム名を含むテーブルの詳細が表示されます。
CREATE TABLE cycling.comments (
    id uuid,
    created_at timestamp,
    comment text,
    commenter text,
    record_id timeuuid,
    solr_query text,
    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', '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';

ALTER TYPE

ALTER TYPE field_name 
  ( ADD field_name cql_datatype
  | RENAME field_name TO new_field_name [ AND field_name TO new_field_name ...] ) ;
詳細情報

このセクションでは、完全名型を使用します。

フィールドの追加

ユーザー定義型に新しいフィールドを追加するには、ALTER TYPEとADDキーワードを使用します。既存のUDTでは、フィールド値はNullです。
ALTER TYPE cycling.fullname 
   ADD middlename text;

フィールド名の変更

ユーザー定義型のフィールド名を変更するには、RENAME old_name TO new_name構文を使用します。ANDでディレクティブを区切って、複数のフィールドの名前を変更します。

cycling.fullname UDTのすべてのフィールド名の名前を削除します。
ALTER TYPE cycling.fullname 
  RENAME middlename TO middle 
  AND lastname TO last 
  AND firstname TO first;

describeを使用して変更を確認します。

DESC TYPE cycling.fullname
新しいフィールド名が説明に表示されます。
CREATE TYPE cycling.fullname (
    first text,
    last text,
    middle text
);

BATCH

BEGIN [ ( UNLOGGED | LOGGED ) ] BATCH 
  [ USING TIMESTAMP [ epoch_microseconds ] ]
  dml_statement [ USING TIMESTAMP [ epoch_microseconds ] ] ;
  [ dml_statement [ USING TIMESTAMP [ epoch_microseconds ] ] [ ; ... ] ] ;
  APPLY BATCH ;
詳細情報

このセクションでは、cyclist_expensesテーブルおよびpopular_countテーブルを使用します。

クライアント指定タイムスタンプをすべてのDMLに適用する

レコードの挿入時にユーザー定義の日付を使用してVera Adrianの食費を挿入します。
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;
注: 2つの文を同じパーティションに組み合わせると、1つのテーブル・ミューテーションが作成されます。
cqlshでレコードを縦方向に表示します。
EXPAND ON
タイムスタンプがすべて同じであることを確認します。
SELECT
  cyclist_name, expense_id,
  amount, WRITETIME(amount),
  description, WRITETIME(description),
  paid, WRITETIME(paid)
FROM
  cycling.cyclist_expenses
WHERE
  cyclist_name = 'Vera ADRIAN';
両方のレコードが同じタイムスタンプで入力されています。
@ Row 1
------------------------+------------------
 cyclist_name           | Vera ADRIAN
 expense_id             | 2
 amount                 | 13.44
 writetime(amount)      | 1481124356754405
 description            | Lunch
 writetime(description) | 1481124356754405
 paid                   | True
 writetime(paid)        | 1481124356754405

@ Row 2
------------------------+------------------
 cyclist_name           | Vera ADRIAN
 expense_id             | 3
 amount                 | 25
 writetime(amount)      | 1481124356754405
 description            | Dinner
 writetime(description) | 1481124356754405
 paid                   | True
 writetime(paid)        | 1481124356754405

(2 rows)

バッチのDML文で比較して設定する(compare-and-set:CAS)ロジックが使用されていると、エラーが返されます。たとえば、CAS IF NOT EXISTSオプションを使用した以下のバッチが実行されると、エラーが返されます。

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', false
  ) IF NOT EXISTS;

APPLY BATCH;
InvalidRequest: Error from server: code=2200 [Invalid query]
message="Cannot provide custom timestamp for conditional BATCH"

条件付き更新のバッチ処理

軽量トランザクションとして導入された条件付き更新をバッチ処理します。ただし、基になるPaxos実装がパーティションレベルの細分性でのみ動作するため、条件付き更新を含むバッチは1つのパーティション内でのみ動作します。バッチ内の1つの文が条件付き更新である場合は、条件付きロジックがtrueを返す必要があり、それ以外の場合はバッチ全体が失敗します。バッチに2つ以上の条件付き更新が含まれている場合は、すべての条件がtrueを返す必要があり、それ以外の場合はバッチ全体が失敗します。

以下の例では、条件付き更新のバッチ処理を示します。最初の文でIF NOT EXISTS条件句を使用しています。
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;
条件付きバッチでは、カスタム・タイムスタンプを適用することはできません。条件付きバッチ内のUPDATE文とDELETE文は、IN条件を使用して行をフィルター処理できません。

この例の続きでは、バッチ内で静的カラムを条件付き更新と一緒に使用する方法を示します。

カウンター更新のバッチ処理

カウンターのバッチでは、COUNTERオプションを使用する必要があります。カウンター更新は、DataStax Enterpriseの他の書き込みとは異なり、idempotent演算ではないためです。
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;

カウンター以外のバッチにカウンター・カラムを含めることができないように、カウンター・バッチのDML文にカウンター以外のカラムを含めることはできません。カウンター・バッチ文では、カスタム・タイムスタンプを適用できません。

COMMIT SEARCH INDEX

COMMIT SEARCH INDEX ON [keyspace_name.]table_name ;
詳細情報

コメント検索インデックス・テーブルについて検索インデックスをコミットします。
COMMIT SEARCH INDEX ON cycling.comments;

CREATE AGGREGATE

CREATE [ OR REPLACE ] AGGREGATE [ IF NOT EXISTS ] 
  [keyspace_name.]aggregate_name (cql_type)
  SFUNC udf_name 
  STYPE cql_type
  FINALFUNC udf_name 
  INITCOND init_value
  [ DETERMINISTIC ] ;
詳細情報

cyclingキースペースで平均を計算する集計を作成し、team_averageでテストを実施します。
注: このセクションでは、ネイティブのAVG関数と同じ機能を持つ関数を作成する方法について説明します。
  1. stateパラメーターをタプルとして関数を作成します。この関数は、最初の位置で行数をカウントし(レコードごとに1ずつインクリメント)、2番目の位置で現在の行の値を既存の小計に加算して合計を算出して、更新された状態を返します。
    CREATE OR REPLACE FUNCTION cycling.avgState (
      state tuple<int, bigint>,
      val int
    ) 
      CALLED ON NULL INPUT 
      RETURNS tuple<int, bigint> 
      LANGUAGE java AS 
        $$
          if (val != null) { 
            state.setInt(0, state.getInt(0) + 1); 
            state.setLong(1, state.getLong(1) + val.intValue()); 
          } 
          return state; 
        $$
    ;
    注: 簡単なテストを使用して、関数が正しく動作していることを確認します。
    CREATE TABLE cycling.test_avg (
      id int PRIMARY KEY,
      state frozen<tuple<int, bigint>>,
      val int
    );
    
    INSERT INTO cycling.test_avg (
      id, state, val
    ) VALUES (
      1, (6, 9949), 51
    );
    
    INSERT INTO cycling.test_avg (
      id, state, val
    ) VALUES (
      2, (79, 10000), 9999
    );
    
    SELECT state, avgstate(state, val), val
    FROM cycling.test_avg;

    最初の値は1ずつインクリメントされ、2番目の値は状態の初期値とvalの結果です。

     state       | cycling.avgstate(state, val) | val
    -------------+------------------------------+------
       (6, 9949) |                   (7, 10000) |   51
     (79, 10000) |                  (80, 19999) | 9999
  2. 選択したカラムの合計値をレコード数で除算する関数を作成します。
    CREATE OR REPLACE FUNCTION cycling.avgFinal (
      state tuple<int,bigint>
    ) 
      CALLED ON NULL INPUT 
      RETURNS double 
      LANGUAGE java AS 
        $$
          double r = 0; 
          if (state.getInt(0) == 0) return null; 
          r = state.getLong(1); 
          r /= state.getInt(0); 
          return Double.valueOf(r);
        $$ 
    ;
  3. ユーザー定義集計を作成し、カラムの平均値を計算します。
    CREATE OR REPLACE AGGREGATE cycling.average (
      int
    ) 
      SFUNC avgState 
      STYPE tuple<int,bigint> 
      FINALFUNC avgFinal 
      INITCOND (0, 0)
    ;
  4. SELECT文を使用して関数をテストします。
    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';

CREATE CUSTOM INDEX

CREATE CUSTOM INDEX [ IF NOT EXISTS ] [ index_name ]
  ON [keyspace_name.]table_name (column_name)
  USING 'org.apache.cassandra.index.sasi.SASIIndex' 
  [ WITH OPTIONS = { option_map } ] ;
詳細情報

すべての例でcycling.cyclist_nameテーブルを使用します。

カラムに対するSASI PREFIXインデックスの作成

カラムfirstnameに対してSASIインデックスを作成します。
CREATE CUSTOM INDEX fn_prefix 
   ON cycling.comments (commenter) 
   USING 'org.apache.cassandra.index.sasi.SASIIndex';

SASIモードPREFIXはデフォルトで、指定する必要はありません。

カラムに対するSASI CONTAINSインデックスの作成

カラムfirstnameに対してSASIインデックスを作成します。

CREATE CUSTOM INDEX fn_contains 
   ON cycling.comments (comment) 
   USING 'org.apache.cassandra.index.sasi.SASIIndex'
   WITH OPTIONS = { 'mode': 'CONTAINS' };
SASIモードCONTAINSを指定する必要があります。

カラムに対するSASI SPARSEインデックスの作成

テーブルを定義し、カラムageに対してSASIインデックスを作成します。
CREATE CUSTOM INDEX fn_sparse 
   ON cycling.comments (record_id) 
   USING 'org.apache.cassandra.index.sasi.SASIIndex'
   WITH OPTIONS = { 'mode': 'SPARSE' };
SASIモードSPARSEを指定する必要があります。このモードは、タイムスタンプまたはミリ秒センサー読み取り値を格納する密度の高い数値カラムに使用します。

非トークン化アナライザーを使用した、カラムに対するSASI PREFIXインデックスの作成

テーブルを定義し、カラムageに対してSASIインデックスを作成します。
CREATE CUSTOM INDEX  fn_notcasesensitive 
ON cycling.comments (comment) 
USING 'org.apache.cassandra.index.sasi.SASIIndex'
WITH OPTIONS = { 
   'analyzer_class': 'org.apache.cassandra.index.sasi.analyzer.NonTokenizingAnalyzer',
   'case_sensitive': 'false'};
非トークン化アナライザーを使用すると、指定したカラムを分析せずに大文字と小文字の区別または大文字と小文字の正規化を指定できます。

カラムに対するSASI分析インデックスの作成

テーブルを定義し、カラムcommentsに対してSASIインデックスを作成します。
CREATE CUSTOM INDEX stdanalyzer_idx 
   ON cycling.comments (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' }
;

CREATE FUNCTION

CREATE [ OR REPLACE ] FUNCTION [ IF NOT EXISTS ] [keyspace_name.]function_name (argument_list [ , ... ])
  ( CALLED | RETURNS NULL ) ON NULL INPUT RETURNS type 
  [ DETERMINISTIC ]
  [ MONOTONIC [ ON argument_name ] ]
  LANGUAGE ( java | javascript ) AS $$ code_block $$ ;
詳細情報

Javaを使用してFLOG関数を作成する

入力値の対数を計算するfLog関数を上書きするか、作成します。CALLED ON NULL INPUTによって、関数が常に実行されることが保証されます。
CREATE OR REPLACE FUNCTION cycling.fLog (
  input double
) 
  CALLED ON NULL INPUT 
  RETURNS double 
  LANGUAGE java AS 
    $$
      return Double.valueOf(Math.log(input.doubleValue()));
    $$ 
;

Javascriptを使用してSQLに似たLEFT関数を作成する

JavaScriptのテキスト・フィールドから最初のN文字を返す関数を作成します。RETURNS NULL ON NULL INPUTによって、入力値がNullの場合に関数が実行されないことが保証されます。
CREATE OR REPLACE FUNCTION cycling.left (
  column text, num int
) 
  RETURNS NULL ON NULL INPUT 
  RETURNS text 
  LANGUAGE javascript AS 
    $$
      column.substring(0, num)
    $$
;
要求で関数を使用します。
SELECT left(firstname, 1), lastname
FROM cycling.cyclist_name;
 cycling.left(firstname, 1) | lastname
----------------------------+-----------------
                          A |           FRAME
                       null |        MATTHEWS
                       null |             VOS
                          P |       TIRALONGO
                          M |             VOS
                          S |      KRUIKSWIJK
                          A | VAN DER BREGGEN

CREATE INDEX

CREATE INDEX [ IF NOT EXISTS ] index_name
  ON [keyspace_name.]table_name 
  ([ ( KEYS | FULL ) ] column_name) 
  (ENTRIES column_name) ;
詳細情報

クラスター化カラムを対象としたインデックスの作成

複合パーティション・キーを持つテーブルを定義し、クラスター化カラムを対象としたインデックスを作成します。

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)
);
CREATE INDEX rank_idx ON cycling.rank_by_year_and_name (rank);

セット・コレクションまたはリスト・コレクションを対象としたインデックスの作成

セット・コレクションまたはリスト・コレクション・カラムを対象としたインデックスを、他のカラムの場合と同様に作成します。CREATE INDEX文の末尾でコレクション・カラムの名前を丸かっこで囲んで指定します。たとえば、チームのコレクションをcyclist_career_teamsテーブルに追加して、teamsセットのデータのインデックスを作成します。

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

マップ・キーを対象としたインデックスの作成

マップ・コレクション・キーを対象としたインデックスを作成できます。コレクションのマップ値のインデックスが存在する場合は、マップ・コレクション・キーを対象としたインデックスを作成する前に、そのインデックスを削除します。cyclistテーブルに以下のマップ・データが含まれていると仮定します。
{'nation':'CANADA' }
マップ・キーはコロンの左側にあり、マップ値はコロンの右側にあります。

マップ・キーのインデックスを作成するには、ネストした丸かっこの中にKEYSキーワードとマップ名を入れます。

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

テーブルをクエリーするには、WHERE句でCONTAINS KEYを使用します。

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

この例では、2015年のエントリーが含まれているサイクリスト・チームが返されます。

 id                                   | firstname | lastname   | teams
--------------------------------------+-----------+------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 cb07baad-eac8-4f65-b28a-bddc06a0de23 | Elizabeth | ARMITSTEAD | {2011: 'Team Garmin - Cervelo', 2012: 'AA Drink - Leontien.nl', 2013: 'Boels:Dolmans Cycling Team', 2014: 'Boels:Dolmans Cycling Team', 2015: 'Boels:Dolmans Cycling Team'}
 5b6962dd-3f90-4c93-8f61-eabfa4a803e2 |  Marianne |        VOS |                                                                                          {2014: 'Rabobank-Liv Woman Cycling Team', 2015: 'Rabobank-Liv Woman Cycling Team'}

マップ・エントリーを対象としたインデックスの作成

マップ・エントリーを対象としたインデックスを作成できます。ENTRIESインデックスは、既存のインデックスを含まないテーブルのマップ・カラムにのみ作成できます。

コレクション・エントリーのインデックスを作成するには、ネストした丸かっこの中にENTRIESキーワードとマップ名を入れます。
CREATE INDEX blist_idx
ON cycling.birthday_list ( ENTRIES(blist) );

テーブルでマップ・エントリーをクエリーするには、マップ名と値を含んでいるWHERE句を使用します。

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

この例では、同じ年齢のサイクリストを検出します。

 cyclist_name     | blist
------------------+----------------------------------------------------------
   Claudio HEINEN | {'age': '23', 'bday': '27/07/1992', 'nation': 'GERMANY'}
 Laurence BOURQUE |  {'age': '23', 'bday': '27/07/1992', 'nation': 'CANADA'}
同じインデックスを使用して、同じ出身国のサイクリストを検出します。
SELECT *
FROM cycling.birthday_list
WHERE blist['nation'] = 'NETHERLANDS';
 cyclist_name  | blist
---------------+--------------------------------------------------------------
 Luc HAGENAARS | {'age': '28', 'bday': '27/07/1987', 'nation': 'NETHERLANDS'}
   Toine POELS | {'age': '52', 'bday': '27/07/1963', 'nation': 'NETHERLANDS'}

マップ値を対象としたインデックスの作成

マップ値のインデックスを作成するには、ネストした丸かっこの中にVALUES キーワードとマップ名を入れます。
CREATE INDEX blist_values_idx
ON cycling.birthday_list ( VALUES(blist) );

テーブルをクエリーするには、マップ名と値を含んでいるWHERE句を使用します。

SELECT *
FROM cycling.birthday_list
WHERE blist CONTAINS 'NETHERLANDS';
 cyclist_name  | blist
---------------+--------------------------------------------------------------
 Luc HAGENAARS | {'age': '28', 'bday': '27/07/1987', 'nation': 'NETHERLANDS'}
   Toine POELS | {'age': '52', 'bday': '27/07/1963', 'nation': 'NETHERLANDS'}

frozenコレクションのコンテンツ全体のインデックスの作成

FROZENコレクション全体を対象としたインデックスを作成できます。FULLインデックスは、既存のインデックスを含まないテーブルのセット、リスト、またはマップのカラムを対象に作成できます。

FROZEN リストのコンテンツ全体のインデックスを作成します。この例のテーブルは、サイクリストのプロ優勝の数、出場したグランド・ツアー・レースおよびクラシック・レースの数を格納します。

CREATE TABLE cycling.race_starts (
  cyclist_name text PRIMARY KEY,
  rnumbers FROZEN<LIST<int>>
);
コレクション・エントリーのインデックスを作成するには、ネストした丸かっこの中にFULLキーワードとコレクション名を入れます。たとえば、frozenリスト、rnumbersのインデックスを作成します。
CREATE INDEX rnumbers_idx
ON cycling.race_starts ( FULL(rnumbers) );

テーブルをクエリーするには、コレクション名と値を含んでいるWHERE句を使用します。

SELECT *
FROM cycling.race_starts
WHERE rnumbers = [39, 7, 14];
 cyclist_name   | rnumbers
----------------+-------------
 John DEGENKOLB | [39, 7, 14]

CREATE KEYSPACE

CREATE KEYSPACE [ IF NOT EXISTS ] keyspace_name 
  WITH REPLICATION = { replication_map }
  [ AND DURABLE_WRITES = ( true | false ) ] ;
詳細情報

単一ノード評価クラスターを対象としたキースペースの作成

単一ノード評価クラスターを対象としたcyclingキースペースを作成します。
CREATE KEYSPACE cycling
  WITH REPLICATION = { 
   'class' : 'SimpleStrategy', 
   'replication_factor' : 1 
  };

評価クラスターを対象としたキースペースNetworkTopologyStrategyの作成

次の例は、単一ノード評価クラスターにネットワーク・トポロジーを持つキースペースを作成する方法を示しています。
CREATE KEYSPACE cycling 
  WITH REPLICATION = { 
   'class' : 'NetworkTopologyStrategy', 
   'datacenter1' : 1 } 
;
注: datacenter1はデフォルトのデータ・センター名です。データ・センター名を表示するには、dsetool statusを使用します。
dsetool status
データ・センター名、ラック名、ホスト名、およびIPアドレスを返します。
DC: Cassandra       Workload: Cassandra       Graph: no
======================================================
Status=Up/Down
|/ State=Normal/Leaving/Joining/Moving
--   Address          Load             Owns                 Token                                        Rack         Health [0,1]
                                                            0
UN   10.0.0.15   67.44 MiB        ?                    -9223372036854775808                         rack1        0.90
UN   10.0.0.110   766.4 KiB        ?                    0                                            rack2        0.90

Note: you must specify a keyspace to get ownership information.

マルチ・データ・センター環境でのcyclingキースペースの作成

ボストン、シアトル、東京の各データ・センターのレプリケーション係数を設定します。データ・センター名は、スニッチで構成されている名前と一致している必要があります。
CREATE KEYSPACE "Cycling"
  WITH REPLICATION = {
   'class' : 'NetworkTopologyStrategy', 
   'boston'  : 3 , // Datacenter 1 
   'seattle' : 2 , // Datacenter 2
   'tokyo'   : 2   // Datacenter 3
  };
注: レプリケーション・ストラテジ・オプションの詳細については、「キースペース・レプリケーション・ストラテジの変更」を参照してください。

永続書き込みの無効化

cyclingキースペースの書き込みコミット・ログを無効にします。コミット・ログを無効にすると、データ喪失のリスクが高まります。SimpleStrategy環境では無効にしないでください。
CREATE KEYSPACE cycling
  WITH REPLICATION = { 
   'class' : 'NetworkTopologyStrategy',
   'datacenter1' : 3 
  } 
AND DURABLE_WRITES = false ;

CREATE MATERIALIZED VIEW

CREATE MATERIALIZED VIEW [ IF NOT EXISTS ] [keyspace_name.]view_name
  AS SELECT [ (column_list) ]
  FROM [keyspace_name.]table_name
  [ WHERE column_name IS NOT NULL
  [ AND column_name IS NOT NULL ... ] ]
  [ AND relation [ AND ... ] ] 
  PRIMARY KEY ( column_list )
  [ WITH [ table_properties ]
  [ [ AND ] CLUSTERING ORDER BY (cluster_column_name order_option) ] ] ;
詳細情報

このセクションでは、マテリアライズド・ビューの使用を説明するシナリオの例を示します。

マテリアライズド・ビューの基本的な例

これらのテーブルは、最初のシナリオの例で使用されます。
CREATE TABLE IF NOT EXISTS cycling.cyclist_base (
  cid UUID PRIMARY KEY,
  name text,
  age int,
  birthday date,
  country text
);
CREATE TABLE IF NOT EXISTS cycling.cyclist_base_ext (
  cid UUID, 
  name text, 
  age int, 
  birthday date, 
  country text,
  PRIMARY KEY (cid, age, birthday)
);
以下のマテリアライズド・ビュー、cyclist_by_ageでは、ベース・テーブル、cyclist_baseを使用します。WHERE句により、ageカラムとcidカラムがNULL以外の行だけがマテリアライズド・ビューに追加されます。マテリアライズド・ビューでは、ageがパーティション・キーで、cidはクラスター化カラムです。ベース・テーブルで、cidはパーティション・キーです。
CREATE MATERIALIZED VIEW cycling.cyclist_by_age AS
  SELECT age, cid, birthday, country, name
  FROM cycling.cyclist_base 
  WHERE age IS NOT NULL
    AND cid IS NOT NULL
  PRIMARY KEY (age, cid)
  WITH CLUSTERING ORDER BY (cid ASC)
  AND caching = { 'keys' : 'ALL', 'rows_per_partition' : '100' }
  AND comment = 'Based on table cyclist';
クエリー:
SELECT *
FROM cycling.cyclist_by_age;
の結果は以下のとおりです。
 age | cid                                  | birthday   | country       | name
-----+--------------------------------------+------------+---------------+---------------------
  28 | 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47 | 1987-06-07 |   Netherlands |   Steven KRUIKSWIJK
  19 | 1c526849-d3a2-42a3-bcf9-7903c80b3d16 | 1998-12-23 |     Australia |       Kanden GROVES
  19 | 410919ef-bd1b-4efa-8256-b0fd8ab67029 | 1999-01-04 |    Uzbekistan | Iskandarbek SHODIEV
  18 | 15a116fc-b833-4da6-ab9a-4a7775752836 | 1997-08-19 | United States |        Adrien COSTA
  18 | 18f471bf-f631-4bc4-a9a2-d6f6cf5ea503 | 1997-03-29 |   Netherlands |         Bram WELTEN
  18 | ffdfa2a7-5fc6-49a7-bfdc-3fcdcfdd7156 | 1997-02-08 |   Netherlands |    Pascal EENKHOORN
  22 | e7ae5cf3-d358-4d99-b900-85902fda9bb0 | 1993-06-18 |   New Zealand |          Alex FRAME
  27 | c9c9c484-5e4a-4542-8203-8d047a01b8a8 | 1987-09-04 |        Brazil |     Cristian EGIDIO
  27 | d1aad83b-be60-47a4-bd6e-069b8da0d97b | 1987-09-04 |       Germany |     Johannes HEIDER
  20 | 862cc51f-00a1-4d5a-976b-a359cab7300e | 1994-09-04 |       Denmark |       Joakim BUKDAL
  38 | 220844bf-4860-49d6-9a4b-6b5d3a79cbfb | 1977-07-08 |         Italy |     Paolo TIRALONGO
  29 | 96c4c40d-58c8-4710-b73f-681e9b1f70ae | 1989-04-20 |     Australia |     Benjamin DYBALL

(12 rows)
以下のマテリアライズド・ビュー、cyclist_by_birthday_and_ageでは、ベース・テーブル、cyclist_baseを使用します。WHERE句により、ageカラム、birthdayカラム、およびcidカラムがNULL以外の行だけがマテリアライズド・ビューに追加されます。マテリアライズド・ビューでは、cidがパーティション・キーで、birthdayは最初のクラスター化カラムで、ageが2番目のクラスター化カラムです。ベース・テーブルで、cidはパーティション・キーです。
CREATE MATERIALIZED VIEW cycling.cyclist_by_birthday_and_age AS
  SELECT age, cid, birthday, country, name
  FROM cycling.cyclist_base
  WHERE age IS NOT NULL
    AND birthday IS NOT NULL
    AND cid IS NOT NULL
  PRIMARY KEY (cid, birthday, age);
クエリー:
SELECT *
FROM cycling.cyclist_by_birthday_and_age;
の結果は以下のとおりです。
 cid                                  | birthday   | age | country       | name
--------------------------------------+------------+-----+---------------+---------------------
 ffdfa2a7-5fc6-49a7-bfdc-3fcdcfdd7156 | 1997-02-08 |  18 |   Netherlands |    Pascal EENKHOORN
 15a116fc-b833-4da6-ab9a-4a7775752836 | 1997-08-19 |  18 | United States |        Adrien COSTA
 e7ae5cf3-d358-4d99-b900-85902fda9bb0 | 1993-06-18 |  22 |   New Zealand |          Alex FRAME
 c9c9c484-5e4a-4542-8203-8d047a01b8a8 | 1987-09-04 |  27 |        Brazil |     Cristian EGIDIO
 410919ef-bd1b-4efa-8256-b0fd8ab67029 | 1999-01-04 |  19 |    Uzbekistan | Iskandarbek SHODIEV
 d1aad83b-be60-47a4-bd6e-069b8da0d97b | 1987-09-04 |  27 |       Germany |     Johannes HEIDER
 862cc51f-00a1-4d5a-976b-a359cab7300e | 1994-09-04 |  20 |       Denmark |       Joakim BUKDAL
 1c526849-d3a2-42a3-bcf9-7903c80b3d16 | 1998-12-23 |  19 |     Australia |       Kanden GROVES
 18f471bf-f631-4bc4-a9a2-d6f6cf5ea503 | 1997-03-29 |  18 |   Netherlands |         Bram WELTEN
 220844bf-4860-49d6-9a4b-6b5d3a79cbfb | 1977-07-08 |  38 |         Italy |     Paolo TIRALONGO
 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47 | 1987-06-07 |  28 |   Netherlands |   Steven KRUIKSWIJK
 96c4c40d-58c8-4710-b73f-681e9b1f70ae | 1989-04-20 |  29 |     Australia |     Benjamin DYBALL

(12 rows)
以下のマテリアライズド・ビュー、cyclist_by_country_and_birthdayでは、ベース・テーブル、cyclist_baseを使用します。WHERE句により、birthdayカラムとcidカラムがNULL以外で、countryAustraliaに等しい行だけがマテリアライズド・ビューに追加されます。
CREATE MATERIALIZED VIEW cycling.cyclist_by_country_and_birthday AS
  SELECT age, cid, birthday, country, name
  FROM cycling.cyclist_base
  WHERE birthday IS NOT NULL
    AND cid IS NOT NULL
    AND country = 'Australia'
  PRIMARY KEY (cid, country, birthday);
クエリー:
SELECT *
FROM cycling.cyclist_by_country_and_birthday;
の結果は以下のとおりです。
 cid                                  | country   | birthday   | age | name
--------------------------------------+-----------+------------+-----+-----------------
 1c526849-d3a2-42a3-bcf9-7903c80b3d16 | Australia | 1998-12-23 |  19 |   Kanden GROVES
 96c4c40d-58c8-4710-b73f-681e9b1f70ae | Australia | 1989-04-20 |  29 | Benjamin DYBALL

(2 rows)
以下のマテリアライズド・ビュー、cyclist_by_birthday_and_age19では、ベース・テーブル、cyclist_baseを使用します。WHERE句により、birthdayカラムとcidカラムがNULL以外で、age19に等しい行だけがマテリアライズド・ビューに追加されます。
CREATE MATERIALIZED VIEW cycling.cyclist_by_birthday_and_age19 AS
  SELECT age, cid, birthday, country, name
  FROM cycling.cyclist_base
  WHERE birthday IS NOT NULL
    AND cid IS NOT NULL
    AND age = 19
  PRIMARY KEY (cid, birthday, age);
クエリー:
SELECT *
FROM cycling.cyclist_by_birthday_and_age19;
の結果は以下のとおりです。
 cid                                  | birthday   | age | country    | name
--------------------------------------+------------+-----+------------+---------------------
 410919ef-bd1b-4efa-8256-b0fd8ab67029 | 1999-01-04 |  19 | Uzbekistan | Iskandarbek SHODIEV
 1c526849-d3a2-42a3-bcf9-7903c80b3d16 | 1998-12-23 |  19 |  Australia |       Kanden GROVE

(2 rows)
以下のマテリアライズド・ビュー、cyclist_by_age_birthday_cidでは、ベース・テーブル、cyclist_base_extを使用します。WHERE句により、ageカラム、birthdayカラム、およびcidカラムがNULL以外の行だけがマテリアライズド・ビューに追加されます。
CREATE MATERIALIZED VIEW cycling.cyclist_by_age_birthday_cid AS
  SELECT age, cid, birthday, country, name
  FROM cycling.cyclist_base_ext
  WHERE age IS NOT NULL
    AND birthday IS NOT NULL
    AND cid IS NOT NULL
  PRIMARY KEY (age, birthday, cid);
クエリー:
SELECT *
FROM cycling.cyclist_by_age_birthday_cid
WHERE age = 19;
の結果は以下のとおりです。
 cid                                  | birthday   | age | country    | name
--------------------------------------+------------+-----+------------+---------------------
 410919ef-bd1b-4efa-8256-b0fd8ab67029 | 1999-01-04 |  19 | Uzbekistan | Iskandarbek SHODIEV
 1c526849-d3a2-42a3-bcf9-7903c80b3d16 | 1998-12-23 |  19 |  Australia |       Kanden GROVE

(2 rows)
2つの値にWHERE句を使用するクエリー:
SELECT *
FROM cycling.cyclist_by_age_birthday_cid
WHERE age = 19
  AND birthday = '1998-12-23';
の結果は以下のとおりです。
 age | birthday   | cid                                  | country   | name
-----+------------+--------------------------------------+-----------+---------------
  19 | 1998-12-23 | 1c526849-d3a2-42a3-bcf9-7903c80b3d16 | Australia | Kanden GROVES

(1 rows)
クラスター化カラムは順に含める必要があります。このクエリーは以下のルールに違反しています。
SELECT *
FROM cycling.cyclist_by_age_birthday_cid
WHERE birthday = '1998-12-23';
結果:
cyclist_by_age-mv.cql:195:InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot 
execute this query as it might involve data filtering and thus may have unpredictable performance. If you 
want to execute this query despite the performance unpredictability, use ALLOW FILTERING.

マテリアライズド・ビューを使用して、ベース・テーブルで実行できないクエリを実行する

以下のシナリオでは、ALLOW FILTERINGが使用されない限り、ベース・テーブルでは実行できないクエリーをマテリアライズド・ビューを使用して実行する方法を示します。パフォーマンスが低下するため、ALLOW FILTERINGを使用することは推奨されません。このテーブルには、以下のサイクリング・チームのメカニック情報が格納されます。
CREATE TABLE IF NOT EXISTS cycling.mechanic (
  emp_id int,
  dept_id int,
  name text,
  age int,
  birthdate date,
  PRIMARY KEY (emp_id, dept_id)
);
このテーブルには次の行が含まれます。
 emp_id | dept_id | age | birthdate  | name
--------+---------+-----+------------+------------
      5 |       3 |  25 | 1996-10-04 | Lisa SMITH
      1 |       1 |  21 | 1992-06-18 | Fred GREEN
      2 |       1 |  22 | 1993-01-15 | John SMITH
      4 |       2 |  24 | 1995-08-19 | Jack JONES
      3 |       2 |  23 | 1994-02-07 |   Jane DOE

(5 rows)
このマテリアライズド・ビューでは前のテーブルのカラムが選択され、このテーブルとは異なるプライマリ・キーが含まれています。
CREATE MATERIALIZED VIEW cycling.mechanic_view AS
  SELECT emp_id, dept_id, name, age, birthdate
  FROM cycling.mechanic
  WHERE emp_id IS NOT NULL
    AND dept_id IS NOT NULL
    AND name IS NOT NULL
    AND age IS NOT NULL
    AND birthdate IS NOT NULL
  PRIMARY KEY (age, emp_id, dept_id);
このクエリーではageが21の行を取得します。
SELECT *
FROM cycling.mechanic_view
WHERE age = 21;
前のクエリーは、ALLOW FILTERINGを使用しないと、ベース・テーブル上で実行できません。前のクエリーからの出力は以下のとおりです。
 age | emp_id | dept_id | birthdate  | name
-----+--------+---------+------------+------------
  21 |      1 |       1 | 1992-06-18 | Fred GREEN

(1 rows)

CREATE ROLE

CREATE ROLE [ IF NOT EXISTS ] role_name
  [ WITH [ SUPERUSER = ( true | false ) ] 
  [ [ AND ] LOGIN = ( true | false ) ] 
  [ [ AND ] PASSWORD = role_password ] 
  [ [ AND ] OPTIONS = { option_map } ] ] ;
詳細情報

ログイン・アカウントの作成

  1. コーチのログイン・ロールを作成します。
    CREATE ROLE coach 
      WITH PASSWORD = 'All4One2day!' 
      AND LOGIN = true;
    内部認証を行うには、ロールにパスワードが必要です。
  2. ログインして、アカウントが機能することを確認します。
    LOGIN coach
  3. プロンプトに応じてパスワードを入力します。
    Password: 
  4. cqlshプロンプトにはロール名が含まれます。
    coach@cqlsh>

ロールの作成

内部認証を使用する場合のベスト・プラクティスは、パーミッションとログイン・アカウントに別々のロールを作成することです。ロールを作成したら、それをパーミッションとして別のロールに割り当てることができます。詳細については、「GRANT」を参照してください。外部オーセンティケーターのユーザーのロールは、ユーザーのグループ名にマップされます。LDAPマッピングでは、大文字と小文字が区別されます。

cyclingキースペース管理者のロール、つまりcyclingキースペースのみに対してフル・パーミッションを持つロールを作成します。

  1. ロールを作成します。
    CREATE ROLE cycling_admin;
    この時点では、ロールにパーミッションはありません。GRANTとREVOKEを使用してパーミッションを管理します。
    注: あるロールが変更できるのは、別のロールのパーミッションだけです。また、そのロールにもあるロール・パーミッションの変更(GRANTまたはREVOKE)しか行えません。
  2. cyclingキースペースへのフル・アクセスをロールに割り当てます。
    GRANT ALL PERMISSIONS on KEYSPACE cycling to cycling_admin;
  3. このロールをコーチに割り当てます。
    GRANT cycling_admin TO coach;
    これにより、cycling_adminロールを変更することで、すべてのcycling管理者のパーミッションを管理できるようになります。
  4. コーチのパーミッションを表示します。
    LIST ALL PERMISSIONS OF coach;

パスワードの変更

あるロールが変更できるのは、そのロール自身のパスワードと、そのロールが変更パーミッションを持つ別のロールのパスワードです。スーパーユーザーは、どのロールのパスワードでも変更できます。ロールのパスワードを変更するには、ALTERを使用します。
ALTER ROLE sandy WITH PASSWORD='bestTeam';

CREATE SEARCH INDEX

CREATE SEARCH INDEX [ IF NOT EXISTS ] ON [keyspace_name.]table_name
  [ WITH [ COLUMNS column_list { option : value } [ , ... ] ]
  [ [ AND ] PROFILES profile_name [ , ... ] ]
  [ [ AND ] CONFIG { option:value } [ , ... ] ]
  [ [ AND ] OPTIONS { option:value } [ , ... ] ] ] ;
詳細情報

wiki.solrキースペースとテーブル、および指定したオプションで検索インデックスを作成します。

検索インデックスが存在しない場合は作成する
CREATE SEARCH INDEX IF NOT EXISTS ON wiki.solr WITH COLUMNS id, body {excluded : false};
リアルタイム(RT)検索インデックスを作成するが、データのインデックスは再作成しない
CREATE SEARCH INDEX ON wiki.solr WITH CONFIG { realtime:true } AND OPTIONS { reindex : false };

透過的なデータ暗号化(TDE)を使用して検索インデックスを作成する

CREATE SEARCH INDEX IF NOT EXISTS ON wiki.solr WITH COLUMNS c1,c2 {docValues:true} AND PROFILES spaceSavingAll AND CONFIG {directoryFactory:'encrypted'};
サポートされている型のすべてのカラムに対して設定されているdocValuesで検索インデックスを作成する
CREATE SEARCH INDEX ON wiki.solr WITH COLUMNS * { docValues:true };
検索インデックスを作成し、インデックスに含めるカラムとインデックスから除外するカラムを指定する
CREATE SEARCH INDEX ON wiki.solr WITH COLUMNS field1 { indexed:true }, field2 { indexed:false };

インデックスが作成されていないカラムは、HTTPクエリー結果とシングルパス・クエリー結果に含まれています。除外するには、excludedオプションを使用します。

タプルおよびUDTフィールドの制御を使用して検索インデックスを作成する

CREATE SEARCH INDEX ON wiki.solr WITH COLUMNS tuplefield.field1 {docValues:true};
サブフィールドが包含対象として選択されているため、親フィールドが含まれます。

検索インデックスを作成して、HTTPクエリー結果とsinglePassクエリーから除外するカラムを指定する

CREATE SEARCH INDEX ON wiki.solr WITH COLUMNS field1 { excluded:true }, field2 { excluded:false };
除外されたカラムはHTTPクエリー結果に存在しませんが、インデックスが作成されていないカラムは含まれています。

CREATE TABLE

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 order ] ] 
  [ [ AND ] ID = 'table_hash_tag' ] ] ;
詳細情報

cassandra.yaml

cassandra.yamlファイルの場所は、インストールのタイプによって異なります。
パッケージ・インストール /etc/dse/cassandra/cassandra.yaml
tarボール・インストール installation_location/resources/cassandra/conf/cassandra.yaml

frozen UDTを使用したテーブルの作成

frozenユーザー定義型(UDT)を持つrace_winnersテーブルを作成します。
CREATE TABLE cycling.race_winners (
  cyclist_name FROZEN<fullname>, 
  race_name text,
  race_position int,
  PRIMARY KEY (race_name, race_position)
);

UDTの作成方法については、「ユーザー定義型の作成」を参照してください。ユーザー定義型の作成時に非コレクション・フィールドのみが使用される場合に、UDTをunfrozenとして作成できます。テーブルがunfrozen UDTを使用して作成される場合は、フィールド値を個別に更新および削除できます

UUIDをプライマリ・キーとして持つcyclist_nameテーブルの作成

UUIDをプライマリ・キーとして持つcyclist_name テーブルを作成します。
CREATE TABLE cycling.cyclist_name (
  id UUID PRIMARY KEY,
  lastname text,
  firstname text
);

複合プライマリ・キーの作成

cyclist_categoryテーブルを作成して、データを逆順に格納します。
CREATE TABLE cycling.cyclist_category (
  category text,
  points int,
  id UUID,
  lastname text,
  PRIMARY KEY (category, points)
)
WITH CLUSTERING ORDER BY (points DESC);

複合パーティション・キーの作成

サイクリストの年度別ランクのクエリー用に最適化されたテーブルを作成します。
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)
);

CDCログを使用したテーブルの作成

cyclist_idテーブルのChange Data Capture(CDC)ログを作成します。
CREATE TABLE cycling.cyclist_id (
  lastname text,
  firstname text,
  age int,
  id UUID,
  PRIMARY KEY ((lastname, firstname), age)
);
CDCロギングを cassandra.yamlで有効にする必要があります。
注意: CDCロギングを有効にする前に、ログ情報の移動と使用に関する計画を策定してください。ディスク領域の上限に達すると、CDCが有効になっているテーブルへの書き込みは、領域がさらに解放されるまで拒否されます。使用可能なCDC設定の詳細については、「Change-Data-Capture(CDC)領域設定」を参照してください。

降順でのデータの格納

次の例に示すテーブル定義では、ポイントの高い順にカテゴリーが格納されます。
CREATE TABLE cycling.cyclist_category (
  category text,
  points int,
  id UUID,
  lastname text,
  PRIMARY KEY (category, points)
)
WITH CLUSTERING ORDER BY (points DESC);

コミット・ログのリプレイのためのテーブルIDからの復元

元のIDを持つテーブルを再作成して、コミット・ログをリプレイしてテーブル・データの復元を容易にします。
CREATE TABLE cycling.cyclist_emails (
  userid text PRIMARY KEY,
  id UUID,
  emails set<text>
) WITH ID='1bb7516e-b140-11e8-96f8-529269fb1459';

CREATE TYPE

CREATE TYPE [ IF NOT EXISTS ] [keyspace_name].type_name
  (field_name cql_datatype [ , field_name cql_datatype ... ]) ;
詳細情報

次の例では、個々のサイクリストに関する個人データで構成されるユーザー定義型cycling.basic_infoを作成します。

CREATE TYPE cycling.basic_info ( 
    birthday timestamp, 
    nationality text, 
    height text,
    weight text
     );

UDTを定義した後、そのUDTを使用して、カラムを持つテーブルを作成できます。CQLのコレクション・カラムとその他のカラムでは、「ユーザー定義型の使用」に示すように、ユーザー定義型の使用がサポートされています。

次の例では、個々のサイクリストに関する個人データで構成されるユーザー定義型(UDT)cycling.basic_info_withTTLを作成します。これには、タイムスタンプとTime To Live(TTL)で設定されるnext_raceカラムjが含まれます。
CREATE TYPE cycling.basic_info_expire IF NOT EXISTS (
  birthday timestamp,
  nationality text,
  height text,
  weight text,
  next_race text
  ) ;
タイムスタンプとTTLを使用してデータの行全体をテーブルに挿入するには、INSERTコマンドを使用して値を指定します。
INSERT INTO cycling.basic_info_TTL_expire (id, lastname, basics)
  VALUES (e7ae5cf3-d358-4d99-b900-85902fda9bb0, 'FRAME',
  { birthday:'1993-06-18',nationality:'New Zealand',weight:'175',height:'72',next_race:'Amgen Tour of California' }) 
  USING TIMESTAMP 100 AND TTL 10000;
TTLを含む単一値を挿入するには、UPDATEコマンドを使用します。
UPDATE cycling.basic_info_TTL_expire 
  USING TTL 100 
  SET basics.next_race='Tour de France' 
  WHERE id = e7ae5cf3-d358-4d99-b900-85902fda9bb0;
UDTの書き込み時間とTTL値を確認するには、SELECTコマンドでWRITETIMEとTTL関数を使用します。
SELECT WRITETIME(basics), TTL(basics) FROM cycling.basic_info_TTL_expire 
  WHERE id = e7ae5cf3-d358-4d99-b900-85902fda9bb0;
注: UDT textフィールドで単一引用符で囲まれた文字列は、クエリーとCOPYコマンドでは二重引用符を使用して返されます。たとえば、文字列Single ' quoteをUDT textフィールドに格納する場合、文字列はSingle '' Quoteとして返されます。

DELETE

DELETE [ column_name [ term ] [ , ... ] ]
  FROM [keyspace_name.]table_name 
  [ USING TIMESTAMP timestamp_value ]
  WHERE PK_column_conditions 
  [ ( IF EXISTS | IF static_column_conditions ) ] ;
詳細情報

指定されたカラムのデータの行からの削除

特定のカラムのデータを削除するには、DELETEコマンドの後に、カラムをコンマで区切ってリストします。idで指定されたサイクリストについて、firstnameカラムとlastnameカラムのデータをNullに変更します。

DELETE firstname, lastname
FROM cycling.cyclist_name 
WHERE id = e7ae5cf3-d358-4d99-b900-85902fda9bb0;
firstnameとlastnameを削除する前のテーブル・スキーマと入力済みのテーブルは以下のとおりです。
CREATE TABLE cycling.cyclist_name (
  id UUID PRIMARY KEY,
  lastname text,
  firstname text
);
 id                                   | firstname | lastname
--------------------------------------+-----------+-----------------
 e7ae5cf3-d358-4d99-b900-85902fda9bb0 |      Alex |           FRAME
 fb372533-eb95-4bb4-8685-6ef61e994caa |   Michael |        MATTHEWS
 5b6962dd-3f90-4c93-8f61-eabfa4a803e2 |  Marianne |             VOS
 220844bf-4860-49d6-9a4b-6b5d3a79cbfb |     Paolo |       TIRALONGO
 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47 |    Steven |      KRUIKSWIJK
 e7cd5752-bc0d-4157-a80f-7523add8dbcd |      Anna | VAN DER BREGGEN

(6 rows)
結果:
 id                                   | firstname | lastname
--------------------------------------+-----------+-----------------
 e7ae5cf3-d358-4d99-b900-85902fda9bb0 |      null |            null
 fb372533-eb95-4bb4-8685-6ef61e994caa |   Michael |        MATTHEWS
 5b6962dd-3f90-4c93-8f61-eabfa4a803e2 |  Marianne |             VOS
 220844bf-4860-49d6-9a4b-6b5d3a79cbfb |     Paolo |       TIRALONGO
 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47 |    Steven |      KRUIKSWIJK
 e7cd5752-bc0d-4157-a80f-7523add8dbcd |      Anna | VAN DER BREGGEN

(6 rows)

行全体の削除

DELETEの後にカラム名を入力しないと、条件に一致する行全体が削除されます。IF EXISTSを指定して、サイクリスト・エントリーをcyclist_nameテーブルから削除し、条件に一致する行がない場合はエラーを返します。

DELETE FROM cycling.cyclist_name 
WHERE id = e7ae5cf3-d358-4d99-b900-85902fda9bb0
IF EXISTS;
IF EXISTSを使用しない場合、コマンドは標準出力なしで続行されます。IF EXISTSTrueを返す場合(このプライマリ・キーを含む行が存在する場合)、以下のようなテーブルが標準出力で表示されます。
 [applied]
-----------
      True
Alex Frameという名前のサイクリストがテーブルから完全に削除されました。
 id                                   | firstname | lastname
--------------------------------------+-----------+-----------------
 fb372533-eb95-4bb4-8685-6ef61e994caa |   Michael |        MATTHEWS
 5b6962dd-3f90-4c93-8f61-eabfa4a803e2 |  Marianne |             VOS
 220844bf-4860-49d6-9a4b-6b5d3a79cbfb |     Paolo |       TIRALONGO
 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47 |    Steven |      KRUIKSWIJK
 e7cd5752-bc0d-4157-a80f-7523add8dbcd |      Anna | VAN DER BREGGEN

(5 rows)

静的カラム条件に基づく行の削除

IF条件はWHERE句を制限し、非PRIMARY KEYカラム(firstnameやlastnameなど)の値に基づく選択を可能にします。以下の例では、firstnameとlastnameが条件に一致していない場合はサイクリスト・レコードが削除されます。

DELETE FROM cycling.cyclist_name 
WHERE id = fb372533-eb95-4bb4-8685-6ef61e994caa 
IF firstname = 'Michael' AND lastname = 'Smith';
結果には該当するすべてのデータが表示されます。lastnameが条件に一致しなかったため、条件は満たされませんでした。したがって、操作は適用されませんでした。
 [applied] | firstname | lastname
-----------+-----------+----------
     False |   Michael | MATTHEWS

条件付きでデータをカラムから削除する

条件付きでデータをカラムから削除するには、IFまたはIF EXISTS句を使用します。カラム・データの条件付き削除は、UPDATEの条件付き実行に似ています。

指定した行が存在しない場合に処理が実行されないようにするには、IF EXISTSをコマンドに追加します。
DELETE id FROM cycling.cyclist_id 
WHERE lastname = 'JONES' and firstname = 'Bram' 
IF EXISTS;
一方、そのような行が存在しない場合は、条件によってFalseが返され、コマンドは失敗します。この場合、標準出力は次のようになります。
 [applied]
-----------
     False
選択した行の1つ以上のカラム値にテストを適用するには、IF条件を使用します。
DELETE id FROM cycling.cyclist_id 
WHERE lastname = 'WELTEN' AND firstname = 'Bram' 
IF age = 20;
すべての条件がTRUEを返す場合の標準出力は、IF EXISTSがtrueを返した場合と同じになります。いずれかの条件が失敗した場合の標準出力には、[applied]カラムにFalseと表示され、失敗した条件に関する情報も表示されます。
 [applied] | age
-----------+-----
     False |  18
注意: 条件付き削除は、多大なパフォーマンス・コストが発生するので、慎重に使用する必要があります。

DROP AGGREGATE

DROP AGGREGATE [ IF EXISTS ] [keyspace_name.]aggregate_name [ (argument_name [ , ... ]) ] ;
詳細情報

avgState集計をcyclingキースペースから削除します。

DROP AGGREGATE IF EXISTS cycling.avgState;

DROP FUNCTION

DROP FUNCTION [ IF EXISTS ] [keyspace_name.]function_name [ (argument_name [ , ... ]) ] ;
詳細情報

UDFをcyclingキースペースから削除します。

DROP FUNCTION IF EXISTS cycling.fLog;

DROP INDEX

DROP INDEX [ IF EXISTS ] [keyspace_name.]index_name ;
詳細情報

インデックスrank_idxcycling.rank_by_year_and_nameテーブルから削除します。

DROP INDEX IF EXISTS cycling.rank_idx ;

DROP KEYSPACE

DROP KEYSPACE [ IF EXISTS ] keyspace_name ;
詳細情報

cyclingキースペースを削除します。
DROP KEYSPACE cycling IF EXISTS;

DROP MATERIALIZED VIEW

DROP MATERIALIZED VIEW [ IF EXISTS ] [keyspace_name.]view_name ;
詳細情報

cyclist_by_ageマテリアライズド・ビューをcyclistキースペースから削除します。

DROP MATERIALIZED VIEW IF EXISTS cycling.cyclist_by_age;

DROP ROLE

DROP ROLE [ IF EXISTS ] role_name ;
詳細情報

チーム・マネージャー・ロールを削除します。

DROP ROLE IF NOT EXISTS team_manager;

DROP SEARCH INDEX CONFIG

DROP SEARCH INDEX ON [keyspace_name.]table_name
  OPTIONS { option : value } [ , { option : value } ... ] ;
詳細情報

wiki.solrキースペースとテーブル、および指定したオプションの検索インデックスが削除されます。

検索インデックスに関連付けられたリソースを削除します。

DROP SEARCH INDEX ON wiki.solr;

検索インデックスに関連付けられたリソースを維持します。

DROP SEARCH INDEX ON wiki.solr WITH OPTIONS { deleteResources:false };

DROP TABLE

DROP TABLE [ IF EXISTS ] [keyspace_name.]table_name ;
詳細情報

cyclist_nameテーブルを削除します。
DROP TABLE IF EXISTS cycling.cyclist_name;

DROP TYPE

DROP TYPE [ IF EXISTS ] [keyspace_name.]type_name ;
詳細情報

テーブルで使用されている型を削除しようとします。
DROP TYPE IF EXISTS cycling.basic_info;
その型を含むテーブル名を示す次のようなエラーメッセージが表示されます。
InvalidRequest: Error from server: code=2200 [Invalid query] message="Cannot drop user type cycling.basic_info as it is still used by table cycling.cyclist_stats"
型を使用するテーブルを削除します。
DROP TABLE IF EXISTS cycling.cyclist_stats;
型を削除します。
DROP TYPE IF EXISTS cycling.basic_info;

GRANT

GRANT permission
  ON object
  TO role_name ;
詳細情報

ほとんどの環境では、ユーザー認証はLDAPなどの外部ディレクトリー・サービスに照らしてユーザー認証情報を確認するプラグインによって処理されます。簡潔にするため、以下の例では内部ユーザーを使用します。

オブジェクト・パーミッションの管理

AUTHORIZEを使用して、ロールが特定のリソースのアクセス制御を管理できるようにします。
  • cyclingキースペース内のすべてのオブジェクトについて、AUTHORIZEを含むすべてのパーミッション・タイプをロールが付与できるようにします。
    GRANT AUTHORIZE ON KEYSPACE cycling TO cycling_admin;
    警告: これによって、ロールは、そのロールのパーミッションと、継承するロールを変更できるようになるため、cyclingキースペースにおけるスーパーユーザーになります。
  • samロールは、クエリーを実行し、cyclingキースペース内のデータを変更するパーミッションを割り当てることができます。
    GRANT AUTHORIZE FOR SELECT, MODIFY ON KEYSPACE cycling TO sam;
    ヒント: samロールは、AUTHORIZE, AUTHORIZE FOR ...ALTERCREATEDESCRIBE、およびDROPなどの他のパーミッションを別のロールに付与することはできません。

データ・リソースへのアクセス

データ・リソース・パーミッションを使用して、キースペース、テーブル、行、および型へのアクセスを管理します。

cyclingキースペースへのすべてのパーミッションをcycling_adminロールに付与します。
GRANT ALL PERMISSIONS ON KEYSPACE cycling TO cycling_admin;
cyclingキースペースのすべてのテーブルに対してSELECT文を実行し、データを変更するパーミッションをcoachロールに付与します。
GRANT SELECT, MODIFY ON KEYSPACE cycling TO coach;
cyclingキースペースに対してALTER KEYSPACE文を実行し、cyclingキースペース内のすべてのテーブルに対してALTER TABLE文、CREATE INDEX文、およびDROP INDEX文を実行するパーミッションをcoachロールに付与します。
GRANT ALTER ON KEYSPACE cycling TO coach;
cycling.cyclist_categoryテーブルに'Sprint’を含んでいる行に対してSELECT文を実行するパーミッションをmartinロールに付与します。
GRANT SELECT ON 'Sprint' ROWS IN cycling.cyclist_category TO martin;
注: filtering_dataの文字列では大文字と小文字が区別されます。

パーミッションを表示するには、「パーミッションのリスト」を参照してください。

INSERT

INSERT [ JSON ] INTO [keyspace_name.]table_name
  [ column_list VALUES column_values ] 
  [ IF NOT EXISTS ] 
  [ USING [ TTL seconds ] [ [ AND ] TIMESTAMP epoch_in_microseconds ] ] ;
詳細情報

タイムスタンプとTime To Live(TTL)の指定

TTLとタイムスタンプの両方を使用してサイクリスト名を挿入します。

INSERT INTO cycling.cyclist_name (
  id, lastname, firstname
) VALUES (
  6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47, 'KRUIKSWIJK', 'Steven'
)
USING TTL 86400
AND TIMESTAMP 123456789;
  • Time To Live(TTL、秒単位)
  • エポック以来の経過マイクロ秒数のタイムスタンプ

コレクション内でのTime To Live(TTL)とタイムスタンプの指定。

sponsorshipセット・コレクションのTTLとタイムスタンプの両方を使用してサイクリスト名を挿入します。

INSERT INTO cycling.cyclist_sponsors_expire (cyclist_name, sponsorship) 
  VALUES ('PRIETO, Marcela',  {'Castrelli', 'Alfa Romeo'}) 
  USING TIMESTAMP 100 AND TTL 10000;
  • Time To Live(TTL、秒単位)
  • エポック以来の経過マイクロ秒数のタイムスタンプ

コレクションへの値の挿入(セットとマップ)

コレクションにデータを挿入するには、値を中かっこで囲みます。設定した値は一意である必要があります。サイクリストVOSsetとしてチームのリストを挿入します。セットは、テーブル内でteams set<text>として定義されます。
INSERT INTO cycling.cyclist_career_teams (
  id,lastname,teams
 ) VALUES (
  5b6962dd-3f90-4c93-8f61-eabfa4a803e2, 
  'VOS', 
  { 'Rabobank-Liv Woman Cycling Team','Rabobank-Liv Giant','Rabobank Women Team','Nederland bloeit' }
 );
teamsという名前のmapにデータを挿入します。このマップはサイクリストVOSについて直近の2つのチーム・メンバーシップをリストします。マップは、テーブル内でteams map<int, text>として定義されます。
INSERT INTO cycling.cyclist_teams (
  id,firstname,lastname,teams
) VALUES (
  5b6962dd-3f90-4c93-8f61-eabfa4a803e2, 
  'Marianne',
  'VOS', 
  { 2015 : 'Rabobank-Liv Woman Cycling Team', 
    2014 : 'Rabobank-Liv Woman Cycling Team' }
);

コレクション内の1つの項目のサイズは64Kに制限されています。

ユーザー定義型のコレクション・カラムにデータを挿入するには、「ユーザー定義型の使用」で示すように、丸かっこの中で、その型の構成要素を中かっこで囲みます。

行がまだ存在しない場合の行の挿入

IF NOT EXISTSをコマンドに追加して、同じプライマリ・キーを持つ行が既に存在する場合には操作が実行されないようにします。

INSERT INTO cycling.cyclist_name (
  id, lastname, firstname
) VALUES (
  c4b65263-fe58-4846-83e8-f0e1c13d518f, 'RATTO', 'Rissella'
) 
IF NOT EXISTS; 
IF NOT EXISTSがないと、コマンドは標準出力なしで処理されます。IF NOT EXISTSがtrueを返す場合(このプライマリ・キーを含む行が存在する場合)、以下のようなテーブルが標準出力で表示されます。
 [applied]
-----------
      True
ただし行が既に存在する場合、コマンドは失敗し、標準出力には次の例に示すように[applied]カラムの値falseと挿入されなかった値を含むテーブルが表示されます。
 [applied] | id                                   | firstname | lastname
-----------+--------------------------------------+-----------+----------
     False | c4b65263-fe58-4846-83e8-f0e1c13d518f |  Rissella |    RATTO
注: IF NOT EXISTSを使用すると、内部的なPaxosの使用に関連してパフォーマンスへの影響が発生します。Paxosの詳細については、「直列化可能な整合性」を参照してください。

LIST PERMISSIONS

LIST ( ALL PERMISSIONS | permission_list )
  [ ON resource_name ]
  [ OF role_name ] 
  [ NORECURSIVE ] ;
詳細情報

すべてのロールとリソースに対するすべてのパーミッション

すべてのリソースですべてのロールに付与されているパーミッションをリストします。
LIST ALL PERMISSIONS;

個別のロール・パーミッション

samに付与されているすべてのパーミッションをリストします。
LIST ALL PERMISSIONS OF sam;
出力は以下のようになります。
 role | username | resource           | permission | granted | restricted | grantable
------+----------+--------------------+------------+---------+------------+-----------
  sam |      sam | <keyspace cycling> |     SELECT |   False |      False |      True
  sam |      sam | <keyspace cycling> |     MODIFY |   False |      False |      True

(2 rows)

リソースに対するすべてのパーミッション

cyclist_nameテーブルに対するすべてのパーミッションをリストします。
LIST ALL PERMISSIONS ON cycling.cyclist_name;
出力は以下のようになります。
 role            | username        | resource           | permission | granted | restricted | grantable
-----------------+-----------------+--------------------+------------+---------+------------+-----------
           coach |           coach | <keyspace cycling> |      ALTER |    True |      False |     False
           coach |           coach | <keyspace cycling> |     SELECT |    True |      False |     False
           coach |           coach | <keyspace cycling> |     MODIFY |    True |      False |     False
   cycling_admin |   cycling_admin | <keyspace cycling> |     CREATE |    True |      False |     False
   cycling_admin |   cycling_admin | <keyspace cycling> |      ALTER |    True |      False |     False
   cycling_admin |   cycling_admin | <keyspace cycling> |       DROP |    True |      False |     False
   cycling_admin |   cycling_admin | <keyspace cycling> |     SELECT |    True |      False |     False
   cycling_admin |   cycling_admin | <keyspace cycling> |     MODIFY |    True |      False |     False
   cycling_admin |   cycling_admin | <keyspace cycling> |  AUTHORIZE |    True |      False |     False
   cycling_admin |   cycling_admin | <keyspace cycling> |   DESCRIBE |    True |      False |     False
 cycling_analyst | cycling_analyst | <keyspace cycling> |     SELECT |    True |      False |     False
        dantest1 |        dantest1 | <keyspace cycling> |  AUTHORIZE |    True |      False |     False
        db_admin |        db_admin | <keyspace cycling> |     SELECT |   False |       True |     False
        db_admin |        db_admin | <keyspace cycling> |     MODIFY |   False |       True |     False
          martin |          martin |    <all keyspaces> |     CREATE |   False |       True |     False
          martin |          martin | <keyspace cycling> |     CREATE |    True |      False |     False
      role_admin |      role_admin | <keyspace cycling> |     SELECT |   False |       True |     False
      role_admin |      role_admin | <keyspace cycling> |     MODIFY |   False |       True |     False
             sam |             sam | <keyspace cycling> |     SELECT |   False |      False |      True
             sam |             sam | <keyspace cycling> |     MODIFY |   False |      False |      True
    team_manager |    team_manager | <keyspace cycling> |     MODIFY |    True |      False |     False

(21 rows)

LIST ROLES

LIST ROLES 
  [ OF role_name ] 
  [ NORECURSIVE ] ;
詳細情報

すべてのロール

現在のロールが記述するためのパーミッションを持っているすべてのロールを表示します。
LIST ROLES;

(内部管理ロールのみ)ロールに割り当てられているロール

特定のロールについてロールを表示します。この情報を表示するための十分な権限が必要です。
LIST ROLES OF coach;
martinに割り当てられているロールのみが返されます。
 role          | super | login | options
---------------+-------+-------+---------
         coach | False | False |        {}
 cycling_admin | False |  True |        {}

(2 rows)

REBUILD SEARCH INDEX

REBUILD SEARCH INDEX ON [keyspace_name.]table_name
  [ WITH OPTIONS { deleteAll : ( true | false ) } ] ;
詳細情報

wiki.solrキースペースとテーブルについて検索インデックスをリビルドします。

REBUILD SEARCH INDEX ON wiki.solr WITH OPTIONS { deleteAll:true };

RELOAD SEARCH INDEX

RELOAD SEARCH INDEX ON [keyspace_name.]table_name ;
詳細情報

wiki.solrキースペースについて検索インデックスのスキーマと構成を再度読み込みます。

RELOAD SEARCH INDEX ON wiki.solr;

RESTRICT

RESTRICT permission
  ON [keyspace_name.]table_name 
  TO role_name ;
詳細情報

ロール管理者はcyclingキースペース内のどのデータも見ることができません。
RESTRICT MODIFY, SELECT ON KEYSPACE cycling TO role_admin;

RESTRICT ROWS

RESTRICT ROWS 
  ON [keyspace_name.]table_name 
  USING pk_column_name ;
詳細情報

cyclist_expensesテーブルについて、パーミッションを割り当てることができるようにフィルター処理するcyclist_nameカラムを構成します。この例では、カラムを識別して各サイクリストが各自の経費のみを表示できるようにします。

RESTRICT ROWS ON cyclist_expenses USING cyclist_name;
RLACには、単一のRESTRICTコマンドと1つ以上のGRANTコマンドの2つのコマンドが必要です。たとえば、Vera Adrianというサイクリストは自分の経費を表示できます。
GRANT SELECT ON 'Vera ADRIAN' ROWS IN cyclist_expenses TO cycling_accounts;
注: filtering_dataの文字列では大文字と小文字が区別されます。

REVOKE

REVOKE permission 
  ON resource_name
  FROM role_name ;
詳細情報

ロールcouchは、クエリーを実行したり、cyclingキースペース内のデータを変更できなくなります。
REVOKE SELECT, MODIFY ON KEYSPACE cycling 
FROM coach;
制約事項:

以下のいずれかの条件を満たす場合、継承により、ユーザーはcycling.nameに対してSELECTクエリーを実行できます。

  • ユーザーがスーパーユーザーである。
  • ユーザーにALL KEYSPACESに対するSELECTパーミッションがある。
  • ユーザーにcyclingキースペースに対するSELECTパーミッションがある。
ロールcoachは、cyclingキースペースを対象にALTERコマンドを実行できなくなります。
REVOKE ALTER ON KEYSPACE cycling 
FROM coach;

SELECT

SELECT [ JSON ] selectors 
  FROM [keyspace_name.]table_name 
  [ WHERE [ primary_key_conditions ] [ AND ] [ index_conditions ]
  [ GROUP BY column_name [ , ... ] ]
  [ ORDER BY PK_column_name [ , ... ] ( ASC | DESC ) ] 
  [ ( LIMIT N | PER PARTITION LIMIT N ) ]
  [ ALLOW FILTERING ] ;
詳細情報

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つまたは複数の関係が含まれます。

カラムの仕様

関係のカラム指定は、以下のいずれかである必要があります。
  • テーブルのパーティション・キーの1つまたは複数のメンバー。
  • クラスター化カラム(関係の前にパーティション・キー内のすべてのカラムを指定する他の関係がある場合)。
  • CREATE INDEXを使用してインデックスが作成されたカラム。
制約事項: WHERE句では、別名ではなく実際の名前を使用してカラムを参照してください。

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

このテーブルには、パーティション・キーとしてidがあります(これは、プライマリ・キーの唯一のカラムであるため、デフォルトのパーティション・キーになります)。
CREATE TABLE cycling.cyclist_career_teams (
  id UUID PRIMARY KEY,
  lastname text,
  teams set<text>
);
このクエリーでは、WHERE句にパーティション・キーid値が含まれています。
SELECT id, lastname, teams 
FROM cycling.cyclist_career_teams 
WHERE id = 5b6962dd-3f90-4c93-8f61-eabfa4a803e2;
制約事項: パーティション・キーを参照する関係は、等価演算子=またはINしか使用できません。IN演算子の詳細については、以下の「」を参照してください。

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

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カラムの前にあるプライマリ・キー・カラムの値を指定するWHERE句が含まれています。
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)
ALLOW FILTERINGを追加して、インデックスなしのクラスター化カラムをフィルター処理できます。
注意: パフォーマンスに影響に与えるため、ALLOW FILTERINGを使用しないでください。
次のテーブル定義には、race_start_dateという名前のクラスター化カラムが含まれていますが、セカンダリ・インデックスはありません。
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
);
ALLOW FILTERINGを使用したクエリーの例:
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)

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

セカンダリ・インデックス付きのカラムがあるテーブルのSELECTWHERE句には、インデックス付きカラムに対する等価関係を少なくとも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が必要になることがあるため、プロダクション環境では使用しないでください。

このテーブルは、raceカラムが最後のクラスター化カラムである例を示しています。
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カラム(最後のクラスター化カラム)の等価条件を持つWHERE句、start_monthカラムのIN句、およびALLOW FILTERING(プロダクション環境では使用しないこと)が含まれています。
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つのノードに送られます。しかし、SELECTIN条件が使用されている場合、キーがトークン範囲のどこに位置するかにより、演算には最大で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)
cyclist_teamsテーブルには、teamsという名前のintキーおよびtext値のマップが含まれています。teamsマップ・キーにはインデックスが付いています。
CREATE INDEX team_year_idx
ON cycling.cyclist_teams ( KEYS (teams) );
インデックスを使用すると、クエリーでマップ・キーをフィルター処理できます。
SELECT *
FROM cycling.cyclist_teams
WHERE teams CONTAINS KEY 2015;

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

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

この例では、マップ・エントリーのインデックスを追加します。
CREATE INDEX blist_idx
ON cycling.birthday_list ( ENTRIES(blist) );
注: この方法はマップにのみ使用できます。
このクエリーは、テーブルbirthday_listblistマップ内のエントリーに基づいて、23歳のサイクリスト全員を検索します。
SELECT *
FROM cycling.birthday_list
WHERE blist['age'] = '23';

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

このセクションの例では、rnumbersという名前のFROZEN listコレクションを含むテーブルを使用しています。この文は、クエリーに必要なインデックスを作成します。
CREATE INDEX rnumbers_idx
ON cycling.race_starts ( FULL(rnumbers) );
このクエリーは、コレクションの値に完全に一致する行を取得します。具体的には、rnumbersから、39回のプロ優勝、7回のグランド・ツアー出場、および14回のクラシック出場の記録を持つサイクリストを取得します。
SELECT *
FROM cycling.race_starts
WHERE rnumbers = [39, 7, 14];

範囲関係

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

このクエリーは、開始日が指定した範囲内にあり、かつrace_idが101であるcycling calendarデータを選択するフィルターを構築します(race_idがプライマリ・キーのコンポーネントではなかった場合、以下のクエリーを使用するためにrace_idにインデックスを作成する必要があります)。
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コンポーネントに等価条件を適用する必要があります。

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

これらの制限は、ORDER BY句を複合プライマリ・キーとともに使用する場合に適用されます。
  1. ORDER BY句にはクラスター化カラムのみを含めます。
  2. WHERE句では、ORDER BY句のカラムの前にあるすべてのパーティション・キー値とクラスター化カラム値を指定します。
  3. 複数のカラムをソートする場合、カラムは、テーブル定義のPRIMARY KEY句のカラムのリストと同じ順序でORDER BY句にリストする必要があります。
  4. ソートの順序指定は制限されます。たとえば、テーブル定義でCLUSTERING ORDER BY (start_month ASC, start_day ASC)を使用すると、クエリーでORDER BY start_day, raceを使用できます(デフォルトはASC)。すべてのカラムに適用する場合は、ソートを逆順にすることもできます(例:ORDER BY start_day DESC, race DESC)。
  5. 別名ではなく実際の名前を使用してカラムを参照してください。
複合プライマリ・キーを使用する「cyclist_categoryテーブル」を参照してください。このクエリーは、ポイントについて降順にサイクリスト・カテゴリーを取得します。
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)
このクエリーでは、ORDER BY句に複数のクラスター化カラムがあります。
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()関数は単調関数です。
  • 決定性集計。
このセクションの例では、次のrace_times_summaryテーブルを使用します。
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)
このクエリーは、race_dateカラム値によって行をグループ化します。
SELECT
  race_date, race_time 
FROM
  cycling.race_times_summary
GROUP BY
  race_date;
同じrace_dateカラム値を持つ行の各セットは、クエリー出力に1行にグループ化されます。同じrace_dateカラム値を持つ行のグループが3個あるため、3行が返されます。返される値は、グループについて最初に見つかった値です。
 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)
このクエリーは、race_dateと時間を返すFLOOR (race_time,1h)で行をグループ化します。各グループの行数はCOUNT(*)によって返されます。
SELECT
  race_date, FLOOR(race_time, 1h), COUNT(*)
FROM
  cycling.race_times_summary
GROUP BY
  race_date, FLOOR(race_time, 1h);
同じrace_dateおよびFLOOR(race_time, 1h)の値を持つ行のグループが9個あるため、9行が返されます。
 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以外の値のカウントの取得

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

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

SELECT COUNT(lastname)
FROM cycling.cyclist_name;

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

SELECTCOUNT(*)を使用すると、クエリーに一致した行の数を返します。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;
次の出力では、カラムがNULLであり、1行が返されることに注意してください:
 start_month | system.max(start_day)
-------------+-----------------------
        null |                  null

(1 rows)

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

SELECTMAX(column_name)を使用すると、カラム内の最大値を返します。カラムのデータ型が数値(bigintdecimaldoublefloatint、または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)
注: WHERE句を含めないと、警告メッセージが表示されます。
Warnings :
Aggregation query used without partition key
MIN関数は最小値を返します。
 system.min(race_points)
-------------------------
                       6

(1 rows)

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

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

クエリーにWHERE句(推奨)が含まれている場合、MAXWHERE条件を満たす行から最大値を返し、MINWHERE条件を満たす行から最小値を返します。

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

この例では、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';
ユーザー定義集計関数(UDA)の作成」および「CREATE AGGREGATE」を参照してください。

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

カラムに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を使用してカラム値のTTLを200秒に設定します。
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';
このクエリーは、指定したrace_nameカラム値の最新のTTLを取得します。
SELECT TTL(race_name) 
FROM cycling.calendar 
WHERE race_id = 200;
出力:
 ttl(race_name)
----------------
            276

(1 rows)

JSON形式の値の取得

Retrieval using JSON」を参照してください。

TRUNCATE

TRUNCATE [ TABLE ] [keyspace_name.]table_name ;
詳細情報

テーブルを削除しないでテーブルのすべてのデータを削除するには:
  1. 必要に応じて、CONSISTENCYコマンドを使用して整合性レベルをALLに設定します。
  2. nodetool statusまたはその他のツールを使用して、すべてのノードが起動し、接続できることを確認します。
  3. TRUNCATEまたはTRUNCATE TABLEの後にテーブル名を指定します。
    TRUNCATE cycling.country_flag;
  4. SELECTを使用して、テーブル・データがTRUNCATEされたことを確認します。
    SELECT * from cycling.country_flag ;
     country | cyclist_name | flag
    ---------+--------------+------
    
    (0 rows)
注: TRUNCATEはすべてのノードに対して、データを保持しているSSTableを指定したテーブルから削除するJMXコマンドを送信します。ノードのいずれかがダウン状態であるか、応答しない場合、コマンドは失敗し、次のようなメッセージが出力されます。
Unable to complete request: one or more nodes were unavailable.

UNRESTRICT

UNRESTRICT permission_name
  ON [keyspace_name.]table_name 
  FROM role_name ; 
詳細情報

cyclingキースペースのデータベース管理者から選択制限を削除します。
UNRESTRICT SELECT ON KEYSPACE cycling FROM db_admin;

UNRESTRICT ROWS

UNRESTRICT ROWS ON [keyspace_name.]table_name ; 
詳細情報

現在選択しているカラムから行レベルのパーミッションを削除します。
UNRESTRICT ROWS ON cyclist_name;

UPDATE

UPDATE [keyspace_name.]table_name
  [ USING TTL time_value ]
  [ [ AND ] USING TIMESTAMP timestamp_value ]
  SET assignment [ , assignment ... ] 
  WHERE row_specification
  [ IF EXISTS | IF condition [ AND condition ] ] ;
詳細情報

カラムの更新

一度に複数行内のカラムを更新するには、以下のようにします。
UPDATE cycling.cyclist_name
SET firstname = NULL
WHERE id IN (
  5b6962dd-3f90-4c93-8f61-eabfa4a803e2, fb372533-eb95-4bb4-8685-6ef61e994caa
);
1行内の複数のカラムを更新するには、以下のようにします。
UPDATE cycling.cyclist_name
SET
  firstname = 'Marianne',
  lastname = 'VOS'
WHERE id = 88b8fd18-b1ed-4e96-bf79-4280797cba80;

タイムスタンプとTTLを使用した更新

set(またはコレクション)値をタイムスタンプおよびTTLで更新するには、以下のように値を指定します。
UPDATE cycling.cyclist_sponsors_expire 
  USING TIMESTAMP 200 AND TTL 20000 
  SET sponsorship += {'Tag Heuer'} 
  WHERE cyclist_name='PRIETO, Marcela';

カウンター・カラムの更新

カウンター・テーブル内のカウンター・カラム値を更新するには、現在値に適用するインクリメントまたはデクリメントを指定します。
UPDATE cycling.popular_count 
SET popularity = popularity + 2 
WHERE id = 6ab09bec-e68e-48d9-a5f8-97e6fb4c9b47;

正確を期すため、軽量トランザクションをカウンター・カラムを対象に使うには、1つまたは複数のカウンター更新をバッチ文に含めます。詳細については、「バッチでの条件付き更新の実行」を参照してください。

USE

USE keyspace_name ;
詳細情報

USE cycling;