Author: tylerhobbs
Date: Wed Jun 3 21:30:33 2015
New Revision: 1683428
URL: http://svn.apache.org/r1683428
Log:
Update CQL docs for 2.2 to the latest
Modified:
cassandra/site/publish/doc/cql3/CQL-2.2.html
Modified: cassandra/site/publish/doc/cql3/CQL-2.2.html
URL:
http://svn.apache.org/viewvc/cassandra/site/publish/doc/cql3/CQL-2.2.html?rev=1683428&r1=1683427&r2=1683428&view=diff
==============================================================================
--- cassandra/site/publish/doc/cql3/CQL-2.2.html (original)
+++ cassandra/site/publish/doc/cql3/CQL-2.2.html Wed Jun 3 21:30:33 2015
@@ -1,4 +1,4 @@
-<?xml version='1.0' encoding='utf-8' ?><!DOCTYPE html PUBLIC "-//W3C//DTD
XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd";><html
xmlns="http://www.w3.org/1999/xhtml";><head><meta http-equiv="Content-Type"
content="text/html; charset=utf-8"/><title>CQL-2.2</title></head><body><p><link
rel="StyleSheet" href="CQL.css" type="text/css" media="screen"></p><h1
id="CassandraQueryLanguageCQLv3.3.0">Cassandra Query Language (CQL)
v3.3.0</h1><span id="tableOfContents"><ol style="list-style: none;"><li><a
href="CQL-2.2.html#CassandraQueryLanguageCQLv3.3.0">Cassandra Query Language
(CQL) v3.3.0</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#CQLSyntax">CQL Syntax</a><ol style="list-style:
none;"><li><a href="CQL-2.2.html#Preamble">Preamble</a></li><li><a
href="CQL-2.2.html#Conventions">Conventions</a></li><li><a
href="CQL-2.2.html#identifiers">Identifiers and keywords</a></li><li><a
href="CQL-2.2.html#constants">Constants</a></li><li><a href="CQL-2.
2.html#Comments">Comments</a></li><li><a
href="CQL-2.2.html#statements">Statements</a></li><li><a
href="CQL-2.2.html#preparedStatement">Prepared
Statement</a></li></ol></li><li><a href="CQL-2.2.html#dataDefinition">Data
Definition</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#createKeyspaceStmt">CREATE KEYSPACE</a></li><li><a
href="CQL-2.2.html#useStmt">USE</a></li><li><a
href="CQL-2.2.html#alterKeyspaceStmt">ALTER KEYSPACE</a></li><li><a
href="CQL-2.2.html#dropKeyspaceStmt">DROP KEYSPACE</a></li><li><a
href="CQL-2.2.html#createTableStmt">CREATE TABLE</a></li><li><a
href="CQL-2.2.html#alterTableStmt">ALTER TABLE</a></li><li><a
href="CQL-2.2.html#dropTableStmt">DROP TABLE</a></li><li><a
href="CQL-2.2.html#truncateStmt">TRUNCATE</a></li><li><a
href="CQL-2.2.html#createIndexStmt">CREATE INDEX</a></li><li><a
href="CQL-2.2.html#dropIndexStmt">DROP INDEX</a></li><li><a
href="CQL-2.2.html#createTypeStmt">CREATE TYPE</a></li><li><a
href="CQL-2.2.html#alterTypeStmt">ALTER TYPE</
a></li><li><a href="CQL-2.2.html#dropTypeStmt">DROP TYPE</a></li><li><a
href="CQL-2.2.html#createTriggerStmt">CREATE TRIGGER</a></li><li><a
href="CQL-2.2.html#dropTriggerStmt">DROP TRIGGER</a></li><li><a
href="CQL-2.2.html#createFunctionStmt">CREATE FUNCTION</a></li><li><a
href="CQL-2.2.html#dropFunctionStmt">DROP FUNCTION</a></li><li><a
href="CQL-2.2.html#createAggregateStmt">CREATE AGGREGATE</a></li><li><a
href="CQL-2.2.html#dropAggregateStmt">DROP AGGREGATE</a></li></ol></li><li><a
href="CQL-2.2.html#dataManipulation">Data Manipulation</a><ol
style="list-style: none;"><li><a
href="CQL-2.2.html#insertStmt">INSERT</a></li><li><a
href="CQL-2.2.html#updateStmt">UPDATE</a></li><li><a
href="CQL-2.2.html#deleteStmt">DELETE</a></li><li><a
href="CQL-2.2.html#batchStmt">BATCH</a></li></ol></li><li><a
href="CQL-2.2.html#queries">Queries</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#selectStmt">SELECT</a></li></ol></li><li><a
href="CQL-2.2.html#types">Data Types</a><ol style="li
st-style: none;"><li><a href="CQL-2.2.html#usingtimestamps">Working with
timestamps</a></li><li><a href="CQL-2.2.html#usingdates">Working with
dates</a></li><li><a href="CQL-2.2.html#usingtime">Working with
time</a></li><li><a href="CQL-2.2.html#counters">Counters</a></li><li><a
href="CQL-2.2.html#collections">Working with
collections</a></li></ol></li><li><a
href="CQL-2.2.html#functions">Functions</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#tokenFun">Token</a></li><li><a
href="CQL-2.2.html#uuidFun">Uuid</a></li><li><a
href="CQL-2.2.html#timeuuidFun">Timeuuid functions</a></li><li><a
href="CQL-2.2.html#blobFun">Blob conversion functions</a></li></ol></li><li><a
href="CQL-2.2.html#udfs">User-Defined Functions</a></li><li><a
href="CQL-2.2.html#udas">User-Defined Aggregates</a></li><li><a
href="CQL-2.2.html#json">JSON Support</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#selectJson">SELECT JSON</a></li><li><a
href="CQL-2.2.html#insertJson">INSERT JSON</a></l
i><li><a href="CQL-2.2.html#jsonEncoding">JSON Encoding of Cassandra Data
Types</a></li><li><a href="CQL-2.2.html#fromJson">The fromJson()
Function</a></li><li><a href="CQL-2.2.html#toJson">The toJson()
Function</a></li></ol></li><li><a href="CQL-2.2.html#appendixA">Appendix A: CQL
Keywords</a></li><li><a href="CQL-2.2.html#appendixB">Appendix B: CQL Reserved
Types</a></li><li><a href="CQL-2.2.html#changes">Changes</a><ol
style="list-style: none;"><li><a
href="CQL-2.2.html#a3.3.0">3.3.0</a></li><li><a
href="CQL-2.2.html#a3.2.0">3.2.0</a></li><li><a
href="CQL-2.2.html#a3.1.7">3.1.7</a></li><li><a
href="CQL-2.2.html#a3.1.6">3.1.6</a></li><li><a
href="CQL-2.2.html#a3.1.5">3.1.5</a></li><li><a
href="CQL-2.2.html#a3.1.4">3.1.4</a></li><li><a
href="CQL-2.2.html#a3.1.3">3.1.3</a></li><li><a
href="CQL-2.2.html#a3.1.2">3.1.2</a></li><li><a
href="CQL-2.2.html#a3.1.1">3.1.1</a></li><li><a
href="CQL-2.2.html#a3.1.0">3.1.0</a></li><li><a
href="CQL-2.2.html#a3.0.5">3.0.5</a></li><li><a href="CQL-
2.2.html#a3.0.4">3.0.4</a></li><li><a
href="CQL-2.2.html#a3.0.3">3.0.3</a></li><li><a
href="CQL-2.2.html#a3.0.2">3.0.2</a></li><li><a
href="CQL-2.2.html#a3.0.1">3.0.1</a></li></ol></li><li><a
href="CQL-2.2.html#Versioning">Versioning</a></li></ol></li></ol></span><h2
id="CQLSyntax">CQL Syntax</h2><h3 id="Preamble">Preamble</h3><p>This document
describes the Cassandra Query Language (CQL) version 3. CQL v3 is not backward
compatible with CQL v2 and differs from it in numerous ways. Note that this
document describes the last version of the languages. However, the <a
href="#changes">changes</a> section provides the diff between the different
versions of CQL v3.</p><p>CQL v3 offers a model very close to SQL in the sense
that data is put in <em>tables</em> containing <em>rows</em> of
<em>columns</em>. For that reason, when used in this document, these terms
(tables, rows and columns) have the same definition than they have in SQL. But
please note that as such, they do <strong>not</strong
> refer to the concept of rows and columns found in the internal
> implementation of Cassandra and in the thrift and CQL v2 API.</p><h3
> id="Conventions">Conventions</h3><p>To aid in specifying the CQL syntax, we
> will use the following conventions in this document:</p><ul><li>Language
> rules will be given in a <a
> href="http://en.wikipedia.org/wiki/Backus%E2%80%93Naur_Form";>BNF</a> -like
> notation:</li></ul><pre class="syntax"><pre><start> ::= TERMINAL
> <non-terminal1> <non-terminal1>
+<?xml version='1.0' encoding='utf-8' ?><!DOCTYPE html PUBLIC "-//W3C//DTD
XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd";><html
xmlns="http://www.w3.org/1999/xhtml";><head><meta http-equiv="Content-Type"
content="text/html; charset=utf-8"/><title>CQL-2.2</title></head><body><p><link
rel="StyleSheet" href="CQL.css" type="text/css" media="screen"></p><h1
id="CassandraQueryLanguageCQLv3.3.0">Cassandra Query Language (CQL)
v3.3.0</h1><span id="tableOfContents"><ol style="list-style: none;"><li><a
href="CQL-2.2.html#CassandraQueryLanguageCQLv3.3.0">Cassandra Query Language
(CQL) v3.3.0</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#CQLSyntax">CQL Syntax</a><ol style="list-style:
none;"><li><a href="CQL-2.2.html#Preamble">Preamble</a></li><li><a
href="CQL-2.2.html#Conventions">Conventions</a></li><li><a
href="CQL-2.2.html#identifiers">Identifiers and keywords</a></li><li><a
href="CQL-2.2.html#constants">Constants</a></li><li><a href="CQL-2.
2.html#Comments">Comments</a></li><li><a
href="CQL-2.2.html#statements">Statements</a></li><li><a
href="CQL-2.2.html#preparedStatement">Prepared
Statement</a></li></ol></li><li><a href="CQL-2.2.html#dataDefinition">Data
Definition</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#createKeyspaceStmt">CREATE KEYSPACE</a></li><li><a
href="CQL-2.2.html#useStmt">USE</a></li><li><a
href="CQL-2.2.html#alterKeyspaceStmt">ALTER KEYSPACE</a></li><li><a
href="CQL-2.2.html#dropKeyspaceStmt">DROP KEYSPACE</a></li><li><a
href="CQL-2.2.html#createTableStmt">CREATE TABLE</a></li><li><a
href="CQL-2.2.html#alterTableStmt">ALTER TABLE</a></li><li><a
href="CQL-2.2.html#dropTableStmt">DROP TABLE</a></li><li><a
href="CQL-2.2.html#truncateStmt">TRUNCATE</a></li><li><a
href="CQL-2.2.html#createIndexStmt">CREATE INDEX</a></li><li><a
href="CQL-2.2.html#dropIndexStmt">DROP INDEX</a></li><li><a
href="CQL-2.2.html#createTypeStmt">CREATE TYPE</a></li><li><a
href="CQL-2.2.html#alterTypeStmt">ALTER TYPE</
a></li><li><a href="CQL-2.2.html#dropTypeStmt">DROP TYPE</a></li><li><a
href="CQL-2.2.html#createTriggerStmt">CREATE TRIGGER</a></li><li><a
href="CQL-2.2.html#dropTriggerStmt">DROP TRIGGER</a></li><li><a
href="CQL-2.2.html#createFunctionStmt">CREATE FUNCTION</a></li><li><a
href="CQL-2.2.html#dropFunctionStmt">DROP FUNCTION</a></li><li><a
href="CQL-2.2.html#createAggregateStmt">CREATE AGGREGATE</a></li><li><a
href="CQL-2.2.html#dropAggregateStmt">DROP AGGREGATE</a></li></ol></li><li><a
href="CQL-2.2.html#dataManipulation">Data Manipulation</a><ol
style="list-style: none;"><li><a
href="CQL-2.2.html#insertStmt">INSERT</a></li><li><a
href="CQL-2.2.html#updateStmt">UPDATE</a></li><li><a
href="CQL-2.2.html#deleteStmt">DELETE</a></li><li><a
href="CQL-2.2.html#batchStmt">BATCH</a></li></ol></li><li><a
href="CQL-2.2.html#queries">Queries</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#selectStmt">SELECT</a></li></ol></li><li><a
href="CQL-2.2.html#databaseRoles">Database Roles</a><
ol style="list-style: none;"><li><a href="CQL-2.2.html#createRoleStmt">CREATE
ROLE</a></li><li><a href="CQL-2.2.html#alterRoleStmt">ALTER ROLE</a></li><li><a
href="CQL-2.2.html#dropRoleStmt">DROP ROLE</a></li><li><a
href="CQL-2.2.html#grantRoleStmt">GRANT ROLE</a></li><li><a
href="CQL-2.2.html#revokeRoleStmt">REVOKE ROLE</a></li><li><a
href="CQL-2.2.html#createUserStmt">CREATE USER </a></li><li><a
href="CQL-2.2.html#alterUserStmt">ALTER USER </a></li><li><a
href="CQL-2.2.html#dropUserStmt">DROP USER </a></li><li><a
href="CQL-2.2.html#listUsersStmt">LIST USERS</a></li></ol></li><li><a
href="CQL-2.2.html#dataControl">Data Control</a><ol style="list-style:
none;"><li><a href="CQL-2.2.html#permissions">Permissions </a></li><li><a
href="CQL-2.2.html#grantPermissionsStmt">GRANT PERMISSION</a></li><li><a
href="CQL-2.2.html#revokePermissionsStmt">REVOKE
PERMISSION</a></li></ol></li><li><a href="CQL-2.2.html#types">Data Types</a><ol
style="list-style: none;"><li><a href="CQL-2.2.html#usingti
mestamps">Working with timestamps</a></li><li><a
href="CQL-2.2.html#usingdates">Working with dates</a></li><li><a
href="CQL-2.2.html#usingtime">Working with time</a></li><li><a
href="CQL-2.2.html#counters">Counters</a></li><li><a
href="CQL-2.2.html#collections">Working with
collections</a></li></ol></li><li><a
href="CQL-2.2.html#functions">Functions</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#tokenFun">Token</a></li><li><a
href="CQL-2.2.html#uuidFun">Uuid</a></li><li><a
href="CQL-2.2.html#timeuuidFun">Timeuuid functions</a></li><li><a
href="CQL-2.2.html#blobFun">Blob conversion functions</a></li></ol></li><li><a
href="CQL-2.2.html#udfs">User-Defined Functions</a></li><li><a
href="CQL-2.2.html#udas">User-Defined Aggregates</a></li><li><a
href="CQL-2.2.html#json">JSON Support</a><ol style="list-style: none;"><li><a
href="CQL-2.2.html#selectJson">SELECT JSON</a></li><li><a
href="CQL-2.2.html#insertJson">INSERT JSON</a></li><li><a
href="CQL-2.2.html#jsonEncoding">JSON Enc
oding of Cassandra Data Types</a></li><li><a href="CQL-2.2.html#fromJson">The
fromJson() Function</a></li><li><a href="CQL-2.2.html#toJson">The toJson()
Function</a></li></ol></li><li><a href="CQL-2.2.html#appendixA">Appendix A: CQL
Keywords</a></li><li><a href="CQL-2.2.html#appendixB">Appendix B: CQL Reserved
Types</a></li><li><a href="CQL-2.2.html#changes">Changes</a><ol
style="list-style: none;"><li><a
href="CQL-2.2.html#a3.3.0">3.3.0</a></li><li><a
href="CQL-2.2.html#a3.2.0">3.2.0</a></li><li><a
href="CQL-2.2.html#a3.1.7">3.1.7</a></li><li><a
href="CQL-2.2.html#a3.1.6">3.1.6</a></li><li><a
href="CQL-2.2.html#a3.1.5">3.1.5</a></li><li><a
href="CQL-2.2.html#a3.1.4">3.1.4</a></li><li><a
href="CQL-2.2.html#a3.1.3">3.1.3</a></li><li><a
href="CQL-2.2.html#a3.1.2">3.1.2</a></li><li><a
href="CQL-2.2.html#a3.1.1">3.1.1</a></li><li><a
href="CQL-2.2.html#a3.1.0">3.1.0</a></li><li><a
href="CQL-2.2.html#a3.0.5">3.0.5</a></li><li><a
href="CQL-2.2.html#a3.0.4">3.0.4</a></li><li><a href="CQL-2.
2.html#a3.0.3">3.0.3</a></li><li><a
href="CQL-2.2.html#a3.0.2">3.0.2</a></li><li><a
href="CQL-2.2.html#a3.0.1">3.0.1</a></li></ol></li><li><a
href="CQL-2.2.html#Versioning">Versioning</a></li></ol></li></ol></span><h2
id="CQLSyntax">CQL Syntax</h2><h3 id="Preamble">Preamble</h3><p>This document
describes the Cassandra Query Language (CQL) version 3. CQL v3 is not backward
compatible with CQL v2 and differs from it in numerous ways. Note that this
document describes the last version of the languages. However, the <a
href="#changes">changes</a> section provides the diff between the different
versions of CQL v3.</p><p>CQL v3 offers a model very close to SQL in the sense
that data is put in <em>tables</em> containing <em>rows</em> of
<em>columns</em>. For that reason, when used in this document, these terms
(tables, rows and columns) have the same definition than they have in SQL. But
please note that as such, they do <strong>not</strong> refer to the concept of
rows and columns found i
n the internal implementation of Cassandra and in the thrift and CQL v2
API.</p><h3 id="Conventions">Conventions</h3><p>To aid in specifying the CQL
syntax, we will use the following conventions in this
document:</p><ul><li>Language rules will be given in a <a
href="http://en.wikipedia.org/wiki/Backus%E2%80%93Naur_Form";>BNF</a> -like
notation:</li></ul><pre class="syntax"><pre><start> ::= TERMINAL
<non-terminal1> <non-terminal1>
</pre></pre><ul><li>Nonterminal symbols will have <code><angle
brackets></code>.</li><li>As additional shortcut notations to BNF, we’ll
use traditional regular expression’s symbols (<code>?</code>,
<code>+</code> and <code>*</code>) to signify that a given symbol is optional
and/or can be repeated. We’ll also allow parentheses to group symbols and
the <code>[<characters>]</code> notation to represent any one of
<code><characters></code>.</li><li>The grammar is provided for documentation
purposes and leave some minor details out. For instance, the last column
definition in a <code>CREATE TABLE</code> statement is optional but supported
if present even though the provided grammar in this document suggest it is not
supported. </li><li>Sample code will be provided in a code block:</li></ul><pre
class="sample"><pre>SELECT sample_usage FROM cql;
</pre></pre><ul><li>References to keywords or pieces of CQL code in running
text will be shown in a <code>fixed-width font</code>.</li></ul><h3
id="identifiers">Identifiers and keywords</h3><p>The CQL language uses
<em>identifiers</em> (or <em>names</em>) to identify tables, columns and other
objects. An identifier is a token matching the regular expression <code
lang="a-zA-Z">[a-zA-Z0-9_]</code><code>*</code>.</p><p>A number of such
identifiers, like <code>SELECT</code> or <code>WITH</code>, are
<em>keywords</em>. They have a fixed meaning for the language and most are
reserved. The list of those keywords can be found in <a
href="#appendixA">Appendix A</a>.</p><p>Identifiers and (unquoted) keywords are
case insensitive. Thus <code>SELECT</code> is the same than <code>select</code>
or <code>sElEcT</code>, and <code>myId</code> is the same than
<code>myid</code> or <code>MYID</code> for instance. A convention often used
(in particular by the samples of this documentation) is to use u
pper case for keywords and lower case for other identifiers.</p><p>There is a
second kind of identifiers called <em>quoted identifiers</em> defined by
enclosing an arbitrary sequence of characters in double-quotes(<code>"</code>).
Quoted identifiers are never keywords. Thus <code>"select"</code> is not a
reserved keyword and can be used to refer to a column, while
<code>select</code> would raise a parse error. Also, contrarily to unquoted
identifiers and keywords, quoted identifiers are case sensitive (<code>"My
Quoted Id"</code> is <em>different</em> from <code>"my quoted id"</code>). A
fully lowercase quoted identifier that matches <code
lang="a-zA-Z">[a-zA-Z0-9_]</code><code>*</code> is equivalent to the unquoted
identifier obtained by removing the double-quote (so <code>"myid"</code> is
equivalent to <code>myid</code> and to <code>myId</code> but different from
<code>"myId"</code>). Inside a quoted identifier, the double-quote character
can be repeated to escape it, so <code>"fo
o "" bar"</code> is a valid identifier.</p><h3
id="constants">Constants</h3><p>CQL defines the following kind of
<em>constants</em>: strings, integers, floats, booleans, uuids and
blobs:</p><ul><li>A string constant is an arbitrary sequence of characters
characters enclosed by single-quote(<code>'</code>). One can include a
single-quote in a string by repeating it, e.g. <code>'It''s raining
today'</code>. Those are not to be confused with quoted identifiers that use
double-quotes.</li><li>An integer constant is defined by
<code>'-'?[0-9]+</code>.</li><li>A float constant is defined by
<code>'-'?[0-9]+('.'[0-9]*)?([eE][+-]?[0-9+])?</code>. On top of that,
<code>NaN</code> and <code>Infinity</code> are also float constants.</li><li>A
boolean constant is either <code>true</code> or <code>false</code> up to
case-insensitivity (i.e. <code>True</code> is a valid boolean
constant).</li><li>A <a
href="http://en.wikipedia.org/wiki/Universally_unique_identifier";>UUID</a>
constant is defined b
y <code>hex{8}-hex{4}-hex{4}-hex{4}-hex{12}</code> where <code>hex</code> is
an hexadecimal character, e.g. <code>[0-9a-fA-F]</code> and <code>{4}</code> is
the number of such characters.</li><li>A blob constant is an hexadecimal number
defined by <code>0[xX](hex)+</code> where <code>hex</code> is an hexadecimal
character, e.g. <code>[0-9a-fA-F]</code>.</li></ul><p>For how these constants
are typed, see the <a href="#types">data types section</a>.</p><h3
id="Comments">Comments</h3><p>A comment in CQL is a line beginning by either
double dashes (<code>--</code>) or double slash
(<code>//</code>).</p><p>Multi-line comments are also supported through
enclosure within <code>/*</code> and <code>*/</code> (but nesting is not
supported).</p><pre class="sample"><pre>-- This is a comment
// This is a comment too
@@ -387,7 +387,120 @@ CREATE INDEX ON users(birth_year);
SELECT firstname, lastname FROM users WHERE birth_year = 1981;
</pre></pre><p>because in both case, Cassandra guarantees that these queries
performance will be proportional to the amount of data returned. In particular,
if no users are born in 1981, then the second query performance will not depend
of the number of user profile stored in the database (not directly at least:
due to secondary index implementation consideration, this query may still
depend on the number of node in the cluster, which indirectly depends on the
amount of data stored. Nevertheless, the number of nodes will always be
multiple number of magnitude lower than the number of user profile stored). Of
course, both query may return very large result set in practice, but the amount
of data returned can always be controlled by adding a
<code>LIMIT</code>.</p><p>However, the following query will be
rejected:</p><pre class="sample"><pre>SELECT firstname, lastname FROM users
WHERE birth_year = 1981 AND country = 'FR';
</pre></pre><p>because Cassandra cannot guarantee that it won’t have to
scan large amount of data even if the result to those query is small.
Typically, it will scan all the index entries for users born in 1981 even if
only a handful are actually from France. However, if you “know what you
are doing”, you can force the execution of this query by using
<code>ALLOW FILTERING</code> and so the following query is valid:</p><pre
class="sample"><pre>SELECT firstname, lastname FROM users WHERE birth_year =
1981 AND country = 'FR' ALLOW FILTERING;
-</pre></pre><h2 id="types">Data Types</h2><p>CQL supports a rich set of data
types for columns defined in a table, including collection types. On top of
those native and collection types, users can also provide custom types (through
a JAVA class extending <code>AbstractType</code> loadable by Cassandra). The
syntax of types is thus:</p><pre class="syntax"><pre><type> ::=
<native-type>
+</pre></pre><h2 id="databaseRoles">Database Roles</h2><h3
id="createRoleStmt">CREATE ROLE</h3><p><i>Syntax:</i></p><pre
class="syntax"><pre><create-role-stmt> ::= CREATE ROLE ( IF NOT EXISTS )?
<identifier> ( WITH <option> ( AND <option> )* )?
+
+<option> ::= PASSWORD = <string>
+ | LOGIN = <boolean>
+ | SUPERUSER = <boolean>
+ | OPTIONS = <map_literal>
+</pre></pre><p></p><p><i>Sample:</i></p><pre class="sample"><pre>CREATE ROLE
new_role;
+CREATE ROLE alice WITH PASSWORD = 'password_a' AND LOGIN = true;
+CREATE ROLE bob WITH PASSWORD = 'password_b' AND LOGIN = true AND SUPERUSER =
true;
+CREATE ROLE carlos WITH OPTIONS = { 'custom_option1' : 'option1_value',
'custom_option2' : 99 };
+</pre></pre><p>By default roles do not possess <code>LOGIN</code> privileges
or <code>SUPERUSER</code> status.</p><p><a href="#permissions">Permissions</a>
on database resources are granted to roles; types of resources include
keyspaces, tables, functions and roles themselves. Roles may be granted to
other roles to create hierarchical permissions structures; in these
hierarchies, permissions and <code>SUPERUSER</code> status are inherited, but
the <code>LOGIN</code> privilege is not. </p><p>If a role has the
<code>LOGIN</code> privilege, clients may identify as that role when
connecting. For the duration of that connection, the client will acquire any
roles and privileges granted to that role.</p><p>Only a client with with the
<code>CREATE</code> permission on the database roles resource may issue
<code>CREATE ROLE</code> requests (see the <a href="#permissions">relevant
section</a> below), unless the client is a <code>SUPERUSER</code>. Role
management in Cassandra is pluggable and
custom implementations may support only a subset of the listed
options.</p><p>Role names should be quoted if they contain non-alphanumeric
characters. </p><h4 id="createRolePwd">Setting credentials for internal
authentication</h4><p>Use the <code>WITH PASSWORD</code> clause to set a
password for internal authentication, enclosing the password in single
quotation marks.<br/>If internal authentication has not been set up or the role
does not have <code>LOGIN</code> privileges, the <code>WITH PASSWORD</code>
clause is not necessary.</p><h4 id="createRoleConditional">Creating a role
conditionally</h4><p>Attempting to create an existing role results in an
invalid query condition unless the <code>IF NOT EXISTS</code> option is used.
If the option is used and the role exists, the statement is a no-op.</p><pre
class="sample"><pre>CREATE ROLE other_role;
+CREATE ROLE IF NOT EXISTS other_role;
+</pre></pre><h3 id="alterRoleStmt">ALTER ROLE</h3><p><i>Syntax:</i></p><pre
class="syntax"><pre><alter-role-stmt> ::= ALTER ROLE <identifier> ( WITH
<option> ( AND <option> )* )?
+
+<option> ::= PASSWORD = <string>
+ | LOGIN = <boolean>
+ | SUPERUSER = <boolean>
+ | OPTIONS = <map_literal>
+</pre></pre><p></p><p><i>Sample:</i></p><pre class="sample"><pre>ALTER ROLE
bob WITH PASSWORD = 'PASSWORD_B' AND SUPERUSER = false;
+</pre></pre><p>Conditions on executing <code>ALTER ROLE</code>
statements:</p><ul><li>A client must have <code>SUPERUSER</code> status to
alter the <code>SUPERUSER</code> status of another role</li><li>A client cannot
alter the <code>SUPERUSER</code> status of any role it currently
holds</li><li>A client can only modify certain properties of the role with
which it identified at login (e.g. <code>PASSWORD</code>)</li><li>To modify
properties of a role, the client must be granted <code>ALTER</code> <a
href="#permissions">permission</a> on that role</li></ul><h3
id="dropRoleStmt">DROP ROLE</h3><p><i>Syntax:</i></p><pre
class="syntax"><pre><drop-role-stmt> ::= DROP ROLE ( IF EXISTS )?
<identifier>
+</pre></pre><p></p><p><i>Sample:</i></p><pre class="sample"><pre>DROP ROLE
alice;
+DROP ROLE IF EXISTS bob;
+</pre></pre><p><code>DROP ROLE</code> requires the client to have
<code>DROP</code> <a href="#permissions">permission</a> on the role in
question. In addition, client may not <code>DROP</code> the role with which it
identified at login. Finaly, only a client with <code>SUPERUSER</code> status
may <code>DROP</code> another <code>SUPERUSER</code> role.<br/>Attempting to
drop a role which does not exist results in an invalid query condition unless
the <code>IF EXISTS</code> option is used. If the option is used and the role
does not exist the statement is a no-op. </p><h3 id="grantRoleStmt">GRANT
ROLE</h3><p><i>Syntax:</i></p><pre class="syntax"><pre><grant-role-stmt> ::=
GRANT <identifier> TO <identifier>
+</pre></pre><p><i>Sample:</i></p><pre class="sample"><pre>GRANT report_writer
TO alice;
+</pre></pre><p>This statement grants the <code>report_writer</code> role to
<code>alice</code>. Any permissions granted to <code>report_writer</code> are
also acquired by <code>alice</code>.<br/>Roles are modelled as a directed
acyclic graph, so circular grants are not permitted. The following examples
result in error conditions:</p><pre class="sample"><pre>GRANT role_a TO role_b;
+GRANT role_b TO role_a;
+</pre></pre><pre class="sample"><pre>GRANT role_a TO role_b;
+GRANT role_b TO role_c;
+GRANT role_c TO role_a;
+</pre></pre><h3 id="revokeRoleStmt">REVOKE ROLE</h3><p><i>Syntax:</i></p><pre
class="syntax"><pre><revoke-role-stmt> ::= REVOKE <identifier> FROM
<identifier>
+</pre></pre><p><i>Sample:</i></p><pre class="sample"><pre>REVOKE report_writer
FROM alice;
+</pre></pre><p>This statement revokes the <code>report_writer</code> role from
<code>alice</code>. Any permissions that <code>alice</code> has acquired via
the <code>report_writer</code> role are also revoked. </p><h4
id="listRolesStmt">LIST ROLES</h4><p><i>Syntax:</i></p><pre
class="syntax"><pre><list-roles-stmt> ::= LIST ROLES ( OF <identifier> )?
( NORECURSIVE )?
+</pre></pre><p><i>Sample:</i> </p><pre class="sample"><pre>LIST ROLES;
+</pre></pre><p>Return all known roles in the system, this requires
<code>DESCRIBE</code> permission on the database roles resource.</p><pre
class="sample"><pre>LIST ROLES OF @alice@;
+</pre></pre><p>Enumerate all roles granted to <code>alice</code>, including
those transitively aquired.</p><pre class="sample"><pre>LIST ROLES OF @bob@
NORECURSIVE
+</pre></pre><p>List all roles directly granted to <code>bob</code>.</p><h3
id="createUserStmt">CREATE USER </h3><p>Prior to the introduction of roles in
Cassandra 2.2, authentication and authorization were based around the concept
of a <code>USER</code>. For backward compatibility, the legacy syntax has been
preserved with <code>USER</code> centric statments becoming synonyms for the
<code>ROLE</code> based equivalents.</p><p><i>Syntax:</i> </p><pre
class="syntax"><pre><create-user-statement> ::= CREATE USER ( IF NOT EXISTS
)? <identifier> ( WITH PASSWORD <string> )? (<option>)?
+
+<option> ::= SUPERUSER
+ | NOSUPERUSER
+</pre></pre><p></p><p><i>Sample:</i> </p><pre class="sample"><pre>CREATE USER
alice WITH PASSWORD 'password_a' SUPERUSER;
+CREATE USER bob WITH PASSWORD 'password_b' NOSUPERUSER;
+</pre></pre><p><code>CREATE USER</code> is equivalent to <code>CREATE
ROLE</code> where the <code>LOGIN</code> option is <code>true</code>. So, the
following pairs of statements are equivalent:</p><pre
class="sample"><pre>CREATE USER alice WITH PASSWORD 'password_a' SUPERUSER;
+CREATE ROLE alice WITH PASSWORD = 'password_a' AND LOGIN = true AND SUPERUSER
= true;
+
+CREATE USER IF EXISTS alice WITH PASSWORD 'password_a' SUPERUSER;
+CREATE ROLE IF EXISTS alice WITH PASSWORD = 'password_a' AND LOGIN = true AND
SUPERUSER = true;
+
+CREATE USER alice WITH PASSWORD 'password_a' NOSUPERUSER;
+CREATE ROLE alice WITH PASSWORD = 'password_a' AND LOGIN = true AND SUPERUSER
= false;
+
+CREATE USER alice WITH PASSWORD 'password_a' NOSUPERUSER;
+CREATE ROLE alice WITH PASSWORD = 'password_a' WITH LOGIN = true;
+
+CREATE USER alice WITH PASSWORD 'password_a';
+CREATE ROLE alice WITH PASSWORD = 'password_a' WITH LOGIN = true;
+</pre></pre><p></p><h3 id="alterUserStmt">ALTER USER </h3><p><i>Syntax:</i>
</p><pre class="syntax"><pre><alter-user-statement> ::= ALTER USER
<identifier> ( WITH PASSWORD <string> )? ( <option> )?
+
+<option> ::= SUPERUSER
+ | NOSUPERUSER
+</pre></pre><p></p><pre class="sample"><pre>ALTER USER alice WITH PASSWORD
'PASSWORD_A';
+ALTER USER bob SUPERUSER;
+</pre></pre><h3 id="dropUserStmt">DROP USER </h3><p><i>Syntax:</i> </p><pre
class="syntax"><pre><drop-user-stmt> ::= DROP USER ( IF EXISTS )?
<identifier>
+</pre></pre><p></p><p><i>Sample:</i> </p><pre class="sample"><pre>DROP USER
alice;
+DROP USER IF EXISTS bob;
+</pre></pre><h3 id="listUsersStmt">LIST USERS</h3><p><i>Syntax:</i></p><pre
class="syntax"><pre><list-users-stmt> ::= LIST USERS;
+</pre></pre><p><i>Sample:</i></p><pre class="sample"><pre>LIST USERS;
+</pre></pre><p>This statement is equivalent to</p><pre
class="sample"><pre>LIST ROLES;
+</pre></pre><p>but only roles with the <code>LOGIN</code> privilege are
included in the output.</p><h2 id="dataControl">Data Control</h2><h3
id="permissions">Permissions </h3><p>Permissions on resources are granted to
roles; there are several different types of resources in Cassandra and each
type is modelled hierarchically:</p><ul><li>The hierarchy of Data resources,
Keyspaces and Tables has the structure <code>ALL KEYSPACES</code> ->
<code>KEYSPACE</code> -> <code>TABLE</code></li><li>Function resources have the
structure <code>ALL FUNCTIONS</code> -> <code>KEYSPACE</code> ->
<code>FUNCTION</code></li><li>Resources representing roles have the structure
<code>ALL ROLES</code> -> <code>ROLE</code></li></ul><p>Permissions can be
granted at any level of these hierarchies and they flow downwards. So granting
a permission on a resource higher up the chain automatically grants that same
permission on all resources lower down. For example, granting
<code>SELECT</code> on a <code>KEYSPACE<
/code> automatically grants it on all <code>TABLES</code> in that
<code>KEYSPACE</code>. Likewise, granting a permission on <code>ALL
FUNCTIONS</code> grants it on every defined function, regardless of which
keyspace it is scoped in. It is also possible to grant permissions on all
functions scoped to a particular keyspace. </p><p>Modifications to permissions
are visible to existing client sessions; that is, connections need not be
re-established following permissions changes.</p><p>The full set of available
permissions
is:</p><ul><li><code>CREATE</code></li><li><code>ALTER</code></li><li><code>DROP</code></li><li><code>SELECT</code></li><li><code>MODIFY</code></li><li><code>AUTHORIZE</code></li><li><code>DESCRIBE</code></li><li><code>EXECUTE</code></li></ul><p>Not
all permissions are applicable to every type of resource. For instance,
<code>EXECUTE</code> is only relevant in the context of functions; granting
<code>EXECUTE</code> on a resource representing a table is nonsensical. At
tempting to <code>GRANT</code> a permission on resource to which it cannot be
applied results in an error response. The following illustrates which
permissions can be granted on which types of resource, and which statements are
enabled by that permission.</p><table><tr><th>permission </th><th>resource
</th><th>operations </th></tr><tr><td><code>CREATE</code>
</td><td><code>ALL KEYSPACES</code> </td><td><code>CREATE
KEYSPACE</code> <br> <code>CREATE TABLE</code> in any
keyspace</td></tr><tr><td><code>CREATE</code>
</td><td><code>KEYSPACE</code> </td><td><code>CREATE
TABLE</code> in specified keyspace</td></tr><tr><td><code>CREATE</code>
</td><td><code>ALL FUNCTIONS</code> </td><td><code>CREATE
FUNCTION</code> in any keyspace <br> <code>CREATE AGGREGATE</code> in any
keyspace</td></tr><tr><td><code>CREATE</code> </td><td><code>ALL FUNCTIONS
IN KEYSPACE</code> </td><td><code>CREATE FUNCTION</code> in
keyspace <br> <code>CREATE AGGREGATE</code> in
keyspace</td></tr><tr><td><code>CREATE</code> </td><td><code>ALL
ROLES</code> </td><td><code>CREATE
ROLE</code></td></tr><tr><td><code>ALTER</code> </td><td><code>ALL
KEYSPACES</code> </td><td><code>ALTER KEYSPACE</code> <br>
<code>ALTER TABLE</code> in any keyspace</td></tr><tr><td><code>ALTER</code>
</td><td><code>KEYSPACE</code> </td><td><code>ALTER
KEYSPACE</code> <br> <code>ALTER TABLE</code> in
keyspace</td></tr><tr><td><code>ALTER</code> </td><td><code>TABLE</code>
</td><td><code>ALTER
TABLE</code></td></tr><tr><td><code>ALTER</code> </td><td><code>ALL
FUNCTIONS</code> </td><td><code>CREATE FUNCTION</code> replacing
any existing <br> <code>CREATE AGGREGATE</code> replacing any
existing</td></tr><tr><td><code>ALTER</code> </td><td><code>ALL FUNCTIONS
IN KEYSPACE</code> </td><td><code>CREATE FUNCTION</code> replacing exis
ting in keyspace <br> <code>CREATE AGGREGATE</code> replacing any existing in
keyspace</td></tr><tr><td><code>ALTER</code>
</td><td><code>FUNCTION</code> </td><td><code>CREATE
FUNCTION</code> replacing existing <br> <code>CREATE AGGREGATE</code> replacing
existing</td></tr><tr><td><code>ALTER</code> </td><td><code>ALL
ROLES</code> </td><td><code>ALTER ROLE</code> on any
role</td></tr><tr><td><code>ALTER</code> </td><td><code>ROLE</code>
</td><td><code>ALTER
ROLE</code></td></tr><tr><td><code>DROP</code> </td><td><code>ALL
KEYSPACES</code> </td><td><code>DROP KEYSPACE</code> <br>
<code>DROP TABLE</code> in any keyspace</td></tr><tr><td><code>DROP</code>
</td><td><code>KEYSPACE</code> </td><td><code>DROP
TABLE</code> in specified keyspace</td></tr><tr><td><code>DROP</code>
</td><td><code>TABLE</code> </td><td><code>DROP
TABLE</code></td></tr><tr
><td><code>DROP</code> </td><td><code>ALL FUNCTIONS</code>
></td><td><code>DROP FUNCTION</code> in any keyspace <br> <code>DROP
>AGGREGATE</code> in any existing</td></tr><tr><td><code>DROP</code>
></td><td><code>ALL FUNCTIONS IN KEYSPACE</code> </td><td><code>DROP
>FUNCTION</code> in keyspace <br> <code>DROP AGGREGATE</code> in
>existing</td></tr><tr><td><code>DROP</code>
></td><td><code>FUNCTION</code> </td><td><code>DROP
>FUNCTION</code></td></tr><tr><td><code>DROP</code> </td><td><code>ALL
>ROLES</code> </td><td><code>DROP ROLE</code> on any
>role</td></tr><tr><td><code>DROP</code> </td><td><code>ROLE</code>
> </td><td><code>DROP
>ROLE</code></td></tr><tr><td><code>SELECT</code> </td><td><code>ALL
>KEYSPACES</code> </td><td><code>SELECT</code> on any
>table</td></tr><tr><td><code>SELECT</code> </td><td><code>KEYSPACE</code>
> </td><td><code>SELECT</code> on
any table in keyspace</td></tr><tr><td><code>SELECT</code>
</td><td><code>TABLE</code> </td><td><code>SELECT</code>
on specified table</td></tr><tr><td><code>MODIFY</code> </td><td><code>ALL
KEYSPACES</code> </td><td><code>INSERT</code> on any table <br>
<code>UPDATE</code> on any table <br> <code>DELETE</code> on any table <br>
<code>TRUNCATE</code> on any table</td></tr><tr><td><code>MODIFY</code>
</td><td><code>KEYSPACE</code> </td><td><code>INSERT</code> on
any table in keyspace <br> <code>UPDATE</code> on any table in keyspace <br>
== @DELETE@ on any table in keyspace ==<br> <code>TRUNCATE</code> on any table
in keyspace</td></tr><tr><td><code>MODIFY</code>
</td><td><code>TABLE</code> </td><td><code>INSERT</code>
<br> <code>UPDATE</code> <br> <code>DELETE</code> <br>
<code>TRUNCATE</code></td></tr><tr><td><code>AUTHORIZE</code>
</td><td><code>ALL KEYSPACES</code> </td><td><co
de>GRANT PERMISSION</code> on any table <br> <code>REVOKE PERMISSION</code> on
any table</td></tr><tr><td><code>AUTHORIZE</code>
</td><td><code>KEYSPACE</code> </td><td><code>GRANT
PERMISSION</code> on table in keyspace <br> <code>REVOKE PERMISSION</code> on
table in keyspace</td></tr><tr><td><code>AUTHORIZE</code>
</td><td><code>TABLE</code> </td><td><code>GRANT
PERMISSION</code> <br> <code>REVOKE PERMISSION</code>
</td></tr><tr><td><code>AUTHORIZE</code> </td><td><code>ALL FUNCTIONS</code>
</td><td><code>GRANT PERMISSION</code> on any function <br>
<code>REVOKE PERMISSION</code> on any
function</td></tr><tr><td><code>AUTHORIZE</code> </td><td><code>ALL FUNCTIONS
IN KEYSPACE</code> </td><td><code>GRANT PERMISSION</code> in keyspace <br>
<code>REVOKE PERMISSION</code> in
keyspace</td></tr><tr><td><code>AUTHORIZE</code> </td><td><code>ALL FUNCTIONS
IN KEYSPACE</code> </td><td><code>GRANT PERMISSION</code> in keyspace <br> <co
de>REVOKE PERMISSION</code> in
keyspace</td></tr><tr><td><code>AUTHORIZE</code>
</td><td><code>FUNCTION</code> </td><td><code>GRANT
PERMISSION</code> <br> <code>REVOKE
PERMISSION</code></td></tr><tr><td><code>AUTHORIZE</code> </td><td><code>ALL
ROLES</code> </td><td><code>GRANT ROLE</code> grant any role
<br> <code>REVOKE ROLE</code> revoke any
role</td></tr><tr><td><code>AUTHORIZE</code> </td><td><code>ROLES</code>
</td><td><code>GRANT ROLE</code> grant role <br> <code>REVOKE
ROLE</code> revoke role</td></tr><tr><td><code>DESCRIBE</code>
</td><td><code>ALL ROLES</code> </td><td><code>LIST
ROLES</code> all roles or only roles granted to another, specified
role</td></tr><tr><td><code>EXECUTE</code> </td><td><code>ALL
FUNCTIONS</code> </td><td><code>SELECT</code>,
<code>INSERT</code>, <code>UPDATE</code> using any function <br> use of any
function in <code>CREATE AGGREGATE</code></td></tr><tr
><td><code>EXECUTE</code> </td><td><code>ALL FUNCTIONS IN KEYSPACE</code>
></td><td><code>SELECT</code>, <code>INSERT</code>, <code>UPDATE</code> using
>any function in keyspace <br> use of any function in keyspace in <code>CREATE
>AGGREGATE</code></td></tr><tr><td><code>EXECUTE</code>
></td><td><code>FUNCTION</code>
></td><td><code>SELECT</code>, <code>INSERT</code>, <code>UPDATE</code> using
>function <br> use of function in <code>CREATE
>AGGREGATE</code></td></tr></table><h3 id="grantPermissionsStmt">GRANT
>PERMISSION</h3><p><i>Syntax:</i> </p><pre
>class="syntax"><pre><grant-permission-stmt> ::= GRANT ( ALL ( PERMISSIONS
>)? | <permission> ( PERMISSION )? ) ON <resource> TO <identifier>
+
+<permission> ::= CREATE | ALTER | DROP | SELECT | MODIFY | AUTHORIZE |
DESRIBE | EXECUTE
+
+<resource> ::= ALL KEYSPACES
+ | KEYSPACE <identifier>
+ | ( TABLE )? <tablename>
+ | ALL ROLES
+ | ROLE <identifier>
+ | ALL FUNCTIONS ( IN KEYSPACE <identifier> )?
+ | FUNCTION <functionname>
+</pre></pre><p></p><p><i>Sample:</i> </p><pre class="sample"><pre>GRANT SELECT
ON ALL KEYSPACES TO data_reader;
+</pre></pre><p>This gives any user with the role <code>data_reader</code>
permission to execute <code>SELECT</code> statements on any table across all
keyspaces</p><pre class="sample"><pre>GRANT MODIFY ON KEYSPACE keyspace1 TO
data_writer;
+</pre></pre><p>This give any user with the role <code>data_writer</code>
permission to perform <code>UPDATE</code>, <code>INSERT</code>,
<code>UPDATE</code>, <code>DELETE</code> and <code>TRUNCATE</code> queries on
all tables in the <code>keyspace1</code> keyspace</p><pre
class="sample"><pre>GRANT DROP ON keyspace1.table1 TO schema_owner;
+</pre></pre><p>This gives any user with the <code>schema_owner</code> role
permissions to <code>DROP</code> <code>keyspace1.table1</code>.</p><pre
class="sample"><pre>GRANT EXECUTE ON FUNCTION keyspace1.user_function( int ) TO
report_writer;
+</pre></pre><p>This grants any user with the <code>report_writer</code> role
permission to execute <code>SELECT</code>, <code>INSERT</code> and
<code>UPDATE</code> queries which use the function
<code>keyspace1.user_function( int )</code></p><pre class="sample"><pre>GRANT
DESCRIBE ON ALL ROLES TO role_admin;
+</pre></pre><p>This grants any user with the <code>role_admin</code> role
permission to view any and all roles in the system with a <code>LIST
ROLES</code> statement</p><h4 id="grantAll">GRANT ALL </h4><p>When the
<code>GRANT ALL</code> form is used, the appropriate set of permissions is
determined automatically based on the target resource.</p><h4
id="autoGrantPermissions">Automatic Granting</h4><p>When a resource is created,
via a <code>CREATE KEYSPACE</code>, <code>CREATE TABLE</code>, <code>CREATE
FUNCTION</code>, <code>CREATE AGGREGATE</code> or <code>CREATE ROLE</code>
statement, the creator (the role the database user who issues the statement is
identified as), is automatically granted all applicable permissions on the new
resource.</p><h3 id="revokePermissionsStmt">REVOKE
PERMISSION</h3><p><i>Syntax:</i> </p><pre
class="syntax"><pre><revoke-permission-stmt> ::= REVOKE ( ALL ( PERMISSIONS
)? | <permission> ( PERMISSION )? ) ON <resource> FROM <identifier>
+
+<permission> ::= CREATE | ALTER | DROP | SELECT | MODIFY | AUTHORIZE |
DESRIBE | EXECUTE
+
+<resource> ::= ALL KEYSPACES
+ | KEYSPACE <identifier>
+ | ( TABLE )? <tablename>
+ | ALL ROLES
+ | ROLE <identifier>
+ | ALL FUNCTIONS ( IN KEYSPACE <identifier> )?
+ | FUNCTION <functionname>
+</pre></pre><p></p><p><i>Sample:</i> </p><pre class="sample"><pre>REVOKE
SELECT ON ALL KEYSPACES FROM data_reader;
+REVOKE MODIFY ON KEYSPACE keyspace1 FROM data_writer;
+REVOKE DROP ON keyspace1.table1 FROM schema_owner;
+REVOKE EXECUTE ON FUNCTION keyspace1.user_function( int ) FROM report_writer;
+REVOKE DESCRIBE ON ALL ROLES FROM role_admin;
+</pre></pre><p></p><h4 id="listPermissionsStmt">LIST
PERMISSIONS</h4><p><i>Syntax:</i></p><pre
class="syntax"><pre><list-permissions-stmt> ::= LIST ( ALL ( PERMISSIONS )?
| <permission> )
+ ( ON <resource> )?
+ ( OF <identifier> ( NORECURSIVE )? )?
+
+<resource> ::= ALL KEYSPACES
+ | KEYSPACE <identifier>
+ | ( TABLE )? <tablename>
+ | ALL ROLES
+ | ROLE <identifier>
+ | ALL FUNCTIONS ( IN KEYSPACE <identifier> )?
+ | FUNCTION <functionname>
+</pre></pre><p></p><p><i>Sample:</i></p><pre class="sample"><pre>LIST ALL
PERMISSIONS OF alice;
+</pre></pre><p>Show all permissions granted to <code>alice</code>, including
those acquired transitively from any other roles. </p><pre
class="sample"><pre>LIST ALL PERMISSIONS ON keyspace1.table1 OF bob;
+</pre></pre><p>Show all permissions on <code>keyspace1.table1</code> granted
to <code>bob</code>, including those acquired transitively from any other
roles. This also includes any permissions higher up the resource hierarchy
which can be applied to <code>keyspace1.table1</code>. For example, should
<code>bob</code> have <code>ALTER</code> permission on <code>keyspace1</code>,
that would be included in the results of this query. Adding the
<code>NORECURSIVE</code> switch restricts the results to only those permissions
which were directly granted to <code>bob</code> or one of <code>bob</code>'s
roles.</p><pre class="sample"><pre>LIST SELECT PERMISSIONS OF carlos;
+</pre></pre><p>Show any permissions granted to <code>carlos</code> or any of
<code>carlos</code>'s roles, limited to <code>SELECT</code> permissions on any
resource.</p><h2 id="types">Data Types</h2><p>CQL supports a rich set of data
types for columns defined in a table, including collection types. On top of
those native and collection types, users can also provide custom types (through
a JAVA class extending <code>AbstractType</code> loadable by Cassandra). The
syntax of types is thus:</p><pre class="syntax"><pre><type> ::=
<native-type>
| <collection-type>
| <tuple-type>
| <string> // Used for custom types. The fully-qualified
name of a JAVA class
@@ -463,6 +576,7 @@ UPDATE plays SET scores = scores - [ 12,
</pre></pre> <p>will select all rows where the <code>timeuuid</code> column
<code>t</code> is strictly older than ‘2013-01-01 00:05+0000’ but
strictly younger than ‘2013-02-02 10:00+0000’. Please note that
<code>t >= maxTimeuuid('2013-01-01 00:05+0000')</code> would still <em>not</em>
select a <code>timeuuid</code> generated exactly at ‘2013-01-01
00:05+0000’ and is essentially equivalent to <code>t >
maxTimeuuid('2013-01-01 00:05+0000')</code>.</p><p><em>Warning</em>: We called
the values generated by <code>minTimeuuid</code> and <code>maxTimeuuid</code>
<em>fake</em> UUID because they do no respect the Time-Based UUID generation
process specified by the <a href="http://www.ietf.org/rfc/rfc4122.txt";>RFC
4122</a>. In particular, the value returned by these 2 methods will not be
unique. This means you should only use those methods for querying (as in the
example above). Inserting the result of those methods is almost certainly <em>a
bad idea</em>.
</p><h4 id="dateOfandunixTimestampOf"><code>dateOf</code> and
<code>unixTimestampOf</code></h4><p>The <code>dateOf</code> and
<code>unixTimestampOf</code> functions take a <code>timeuuid</code> argument
and extract the embedded timestamp. However, while the <code>dateof</code>
function return it with the <code>timestamp</code> type (that most client,
including cqlsh, interpret as a date), the <code>unixTimestampOf</code>
function returns it as a <code>bigint</code> raw value.</p><h3
id="blobFun">Blob conversion functions</h3><p>A number of functions are
provided to “convert” the native types into binary data
(<code>blob</code>). For every <code><native-type></code> <code>type</code>
supported by CQL3 (a notable exceptions is <code>blob</code>, for obvious
reasons), the function <code>typeAsBlob</code> takes a argument of type
<code>type</code> and return it as a <code>blob</code>. Conversely, the
function <code>blobAsType</code> takes a 64-bit <code>blob</code> argum
ent and convert it to a <code>bigint</code> value. And so for instance,
<code>bigintAsBlob(3)</code> is <code>0x0000000000000003</code> and
<code>blobAsBigint(0x0000000000000003)</code> is <code>3</code>.</p><h2
id="udfs">User-Defined Functions</h2><p>User-defined functions allow execution
of user-provided code in Cassandra. By default, Cassandra supports defining
functions in <em>Java</em> and <em>JavaScript</em>. Support for other JSR 223
compliant scripting languages (such as Python, Ruby, and Scala) can be added by
adding a JAR to the classpath.</p><p>UDFs are part of the Cassandra schema. As
such, they are automatically propagated to all nodes in the cluster.</p><p>UDFs
can be <em>overloaded</em> - i.e. multiple UDFs with different argument types
but the same function name. Example:</p><pre class="sample"><pre>CREATE
FUNCTION sample ( arg int ) ...;
CREATE FUNCTION sample ( arg text ) ...;
</pre></pre><p>User-defined functions are susceptible to all of the normal
problems with the chosen programming language. Accordingly, implementations
should be safe against null pointer exceptions, illegal arguments, or any other
potential source of exceptions. An exception during function execution will
result in the entire statement failing.</p><p>It is valid to use
<em>complex</em> types like collections, tuple types and user-defined types as
argument and return types. Tuple types and user-defined types are handled by
the conversion functions of the DataStax Java Driver. Please see the
documentation of the Java Driver for details on handling tuple types and
user-defined types.</p><p>Arguments for functions can be literals or terms.
Prepared statement placeholders can be used, too.</p><p>Note that you can use
the double-quoted string syntax to enclose the UDF source code. For
example:</p><pre class="sample"><pre>CREATE FUNCTION some_function ( arg int )
+ RETURNS NULL ON NULL INPUT
RETURNS int
LANGUAGE java
AS $$ return arg; $$;
@@ -470,7 +584,8 @@ CREATE FUNCTION sample ( arg text ) ...;
SELECT some_function(column) FROM atable ...;
UPDATE atable SET col = some_function(?) ...;
</pre></pre><p></p><pre class="sample"><pre>CREATE TYPE custom_type (txt text,
i int);
-CREATE FUNCTION fct_using_udt ( udtarg frozen<customType> )
+CREATE FUNCTION fct_using_udt ( udtarg frozen<custom_type> )
+ RETURNS NULL ON NULL INPUT
RETURNS text
LANGUAGE java
AS $$ return udtarg.getString("txt"); $$;
@@ -504,7 +619,7 @@ CREATE AGGREGATE average ( int )
FINALFUNC averageFinal
INITCOND (0, 0);
-CREATE TYPE atable (
+CREATE TABLE atable (
pk int PRIMARY KEY,
val int);
INSERT INTO atable (pk, val) VALUES (1,1);
@@ -513,4 +628,4 @@ INSERT INTO atable (pk, val) VALUES (3,3
INSERT INTO atable (pk, val) VALUES (4,4);
SELECT average(val) FROM atable;
</pre></pre><p></p><p>See <a href="#createAggregateStmt"><code>CREATE
AGGREGATE</code></a> and <a href="#dropAggregateStmt"><code>DROP
AGGREGATE</code></a>.</p><h2 id="json">JSON Support</h2><p>Cassandra 2.2
introduces JSON support to <a href="#selectStmt"><code>SELECT</code></a> and <a
href="#insertStmt"><code>INSERT</code></a> statements. This support does not
fundamentally alter the CQL API (for example, the schema is still enforced), it
simply provides a convenient way to work with JSON documents.</p><h3
id="selectJson">SELECT JSON</h3><p>With <code>SELECT</code> statements, the new
<code>JSON</code> keyword can be used to return each row as a single
<code>JSON</code> encoded map. The remainder of the <code>SELECT</code>
statment behavior is the same.</p><p>The result map keys are the same as the
column names in a normal result set. For example, a statement like
"<code>SELECT JSON a, ttl(b) FROM ...</code>" would result in a map with keys
<code>"a"</code> and <code>"ttl(b)"</
code>. However, this is one notable exception: for symmetry with <code>INSERT
JSON</code> behavior, case-sensitive column names with upper-case letters will
be surrounded with double quotes. For example, "<code>SELECT JSON myColumn
FROM ...</code>" would result in a map key <code>"\"myColumn\""</code> (note
the escaped quotes).</p><p>The map values will <code>JSON</code>-encoded
representations (as described below) of the result set values.</p><h3
id="insertJson">INSERT JSON</h3><p>With <code>INSERT</code> statements, the new
<code>JSON</code> keyword can be used to enable inserting a <code>JSON</code>
encoded map as a single row. The format of the <code>JSON</code> map should
generally match that returned by a <code>SELECT JSON</code> statement on the
same table. In particular, case-sensitive column names should be surrounded
with double quotes. For example, to insert into a table with two columns named
“myKey” and “value”, you would do the following:</
p><pre class="sample"><pre>INSERT INTO mytable JSON '{"\"myKey\"": 0, "value":
0}'
-</pre></pre><p>Any columns which are ommitted from the <code>JSON</code> map
will be defaulted to a <code>NULL</code> value (which will result in a
tombstone being created).</p><h3 id="jsonEncoding">JSON Encoding of Cassandra
Data Types</h3><p>Where possible, Cassandra will represent and accept data
types in their native <code>JSON</code> representation. Cassandra will also
accept string representations matching the CQL literal format for all data
types. The following table describes the encodings that Cassandra will accept
in <code>INSERT JSON</code> values (and <code>fromJson()</code> arguments) as
well as the format Cassandra will use when returning data for <code>SELECT
JSON</code> statements (and <code>fromJson()</code>):</p><table><tr><th>type
</th><th>formats accepted </th><th>return format
</th><th>notes</th></tr><tr><td><code>ascii</code> </td><td>string
</td><td>string </td><td>Uses JSON’s <code>\u</code>
character escape</td></tr><
tr><td><code>bigint</code> </td><td>integer, string </td><td>integer
</td><td>String must be valid 64 bit
integer</td></tr><tr><td><code>blob</code> </td><td>string
</td><td>string </td><td>String should be 0x followed by an even
number of hex digits</td></tr><tr><td><code>boolean</code> </td><td>boolean,
string </td><td>boolean </td><td>String must be
“true” or "false"</td></tr><tr><td><code>date</code>
</td><td>string </td><td>string </td><td>Date in
format <code>YYYY-MM-DD</code>, timezone
UTC</td></tr><tr><td><code>decimal</code> </td><td>integer, float,
string</td><td>float </td><td>May exceed 32 or 64-bit IEEE-754
floating point precision in client-side
decoder</td></tr><tr><td><code>double</code> </td><td>integer, float,
string</td><td>float </td><td>String must be valid integer or
float</td></tr><tr><td><code>float</code> </td><td>integer, float,
string</td><td>float </td><td>String must be valid integer or
float</td></tr><tr><td><code>inet</code> </td><td>string
</td><td>string </td><td>IPv4 or IPv6
address</td></tr><tr><td><code>int</code> </td><td>integer, string
</td><td>integer </td><td>String must be valid 32 bit
integer</td></tr><tr><td><code>text</code> </td><td>string
</td><td>string </td><td>Uses JSON’s <code>\u</code> character
escape</td></tr><tr><td><code>time</code> </td><td>string
</td><td>string </td><td>Time of day in format
<code>HH-MM-SS[.fffffffff]</code></td></tr><tr><td><code>timestamp</code></td><td>integer,
string </td><td>string </td><td>A timestamp. Strings constant
are allow to input timestamps as dates, see <a href="#usingdates">Working with
dates</a> below for more information. Datestamps with format <code>YYYY-MM-DD
HH:MM:SS.SSS</code> are returned.</td></
tr><tr><td><code>timeuuid</code> </td><td>string
</td><td>string </td><td>Type 1 UUID. See <a
href="#constants">Constants</a> for the UUID
format</td></tr><tr><td><code>uuid</code> </td><td>string
</td><td>string </td><td>See <a href="#constants">Constants</a> for
the UUID format</td></tr><tr><td><code>varchar</code> </td><td>string
</td><td>string </td><td>Uses JSON’s <code>\u</code>
character escape</td></tr><tr><td><code>varint</code> </td><td>integer,
string </td><td>integer </td><td>Variable length; may overflow
32 or 64 bit integers in client-side decoder</td></tr></table><h3
id="fromJson">The fromJson() Function</h3><p>The <code>fromJson()</code>
function may be used similarly to <code>INSERT JSON</code>, but for a single
column value. It may only be used in the <code>VALUES</code> clause of an
<code>INSERT</code> statement or as one of the column values in an <code>UPDATE<
/code>, <code>DELETE</code>, or <code>SELECT</code> statement. For example,
it cannot be used in the selection clause of a <code>SELECT</code>
statement.</p><h3 id="toJson">The toJson() Function</h3><p>The
<code>toJson()</code> function may be used similarly to <code>SELECT
JSON</code>, but for a single column value. It may only be used in the
selection clause of a <code>SELECT</code> statement.</p><h2
id="appendixA">Appendix A: CQL Keywords</h2><p>CQL distinguishes between
<em>reserved</em> and <em>non-reserved</em> keywords. Reserved keywords cannot
be used as identifier, they are truly reserved for the language (but one can
enclose a reserved keyword by double-quotes to use it as an identifier).
Non-reserved keywords however only have a specific meaning in certain context
but can used as identifer otherwise. The only <em>raison d'être</em> of these
non-reserved keywords is convenience: some keyword are non-reserved when it was
always easy for the parser to decide whether the
y were used as keywords or not.</p><table><tr><th>Keyword
</th><th>Reserved? </th></tr><tr><td><code>ADD</code> </td><td>yes
</td></tr><tr><td><code>AGGREGATE</code> </td><td>no
</td></tr><tr><td><code>ALL</code> </td><td>no
</td></tr><tr><td><code>ALTER</code> </td><td>yes
</td></tr><tr><td><code>AND</code> </td><td>yes
</td></tr><tr><td><code>ANY</code> </td><td>yes
</td></tr><tr><td><code>APPLY</code> </td><td>yes
</td></tr><tr><td><code>AS</code> </td><td>no
</td></tr><tr><td><code>ASC</code> </td><td>yes
</td></tr><tr><td><code>ASCII</code> </td><td>no
</td></tr><tr><td><code>AUTHORIZE</code> </td><td>yes
</td></tr><tr><td><code>BATCH</code> </td><td>yes
</td></tr><tr><td><code>BEGIN</code> </td><td>yes
</td></tr><tr><td><code>BIGINT</code> </td><td>no
</td></tr><tr><td><code>BLOB</code> </td><td>no
</td></tr><tr><td><code>BOOLEAN</code> </td><td>no </t
d></tr><tr><td><code>BY</code> </td><td>yes
</td></tr><tr><td><code>CLUSTERING</code> </td><td>no
</td></tr><tr><td><code>COLUMNFAMILY</code> </td><td>yes
</td></tr><tr><td><code>COMPACT</code> </td><td>no
</td></tr><tr><td><code>CONSISTENCY</code> </td><td>no
</td></tr><tr><td><code>COUNT</code> </td><td>no
</td></tr><tr><td><code>COUNTER</code> </td><td>no
</td></tr><tr><td><code>CREATE</code> </td><td>yes
</td></tr><tr><td><code>DECIMAL</code> </td><td>no
</td></tr><tr><td><code>DELETE</code> </td><td>yes
</td></tr><tr><td><code>DESC</code> </td><td>yes
</td></tr><tr><td><code>DETERMINISTIC</code> </td><td>no
</td></tr><tr><td><code>DOUBLE</code> </td><td>no
</td></tr><tr><td><code>DROP</code> </td><td>yes
</td></tr><tr><td><code>EACH_QUORUM</code> </td><td>yes
</td></tr><tr><td><code>FUNCTION</code> </td><td>no
</td></tr><tr><td><code>FINALFUNC</code> </td><td>no
</td></tr><tr><td><code>FLOAT<
/code> </td><td>no </td></tr><tr><td><code>FROM</code>
</td><td>yes </td></tr><tr><td><code>GRANT</code> </td><td>yes
</td></tr><tr><td><code>IN</code> </td><td>yes
</td></tr><tr><td><code>INDEX</code> </td><td>yes
</td></tr><tr><td><code>CUSTOM</code> </td><td>no
</td></tr><tr><td><code>INITCOND</code> </td><td>no
</td></tr><tr><td><code>INSERT</code> </td><td>yes
</td></tr><tr><td><code>INT</code> </td><td>no
</td></tr><tr><td><code>INTO</code> </td><td>yes
</td></tr><tr><td><code>KEY</code> </td><td>no
</td></tr><tr><td><code>KEYSPACE</code> </td><td>yes
</td></tr><tr><td><code>LANGUAGE</code> </td><td>no
</td></tr><tr><td><code>LEVEL</code> </td><td>no
</td></tr><tr><td><code>LIMIT</code> </td><td>yes
</td></tr><tr><td><code>LOCAL_ONE</code> </td><td>yes
</td></tr><tr><td><code>LOCAL_QUORUM</code> </td><td>yes
</td></tr><tr><td><code>MODIFY</code> </td><td>yes <
/td></tr><tr><td><code>NORECURSIVE</code> </td><td>yes
</td></tr><tr><td><code>NON</code> </td><td>no
</td></tr><tr><td><code>NOSUPERUSER</code> </td><td>no
</td></tr><tr><td><code>OF</code> </td><td>yes
</td></tr><tr><td><code>ON</code> </td><td>yes
</td></tr><tr><td><code>ONE</code> </td><td>yes
</td></tr><tr><td><code>OR</code> </td><td>yes
</td></tr><tr><td><code>ORDER</code> </td><td>yes
</td></tr><tr><td><code>PASSWORD</code> </td><td>no
</td></tr><tr><td><code>PERMISSION</code> </td><td>no
</td></tr><tr><td><code>PERMISSIONS</code> </td><td>no
</td></tr><tr><td><code>PRIMARY</code> </td><td>yes
</td></tr><tr><td><code>QUORUM</code> </td><td>yes
</td></tr><tr><td><code>REPLACE</code> </td><td>yes
</td></tr><tr><td><code>RETURNS</code> </td><td>no
</td></tr><tr><td><code>REVOKE</code> </td><td>yes
</td></tr><tr><td><code>SCHEMA</code> </td><td>yes
</td></tr><tr><td><code>SELEC
T</code> </td><td>yes </td></tr><tr><td><code>SET</code>
</td><td>yes </td></tr><tr><td><code>SFUNC</code> </td><td>no
</td></tr><tr><td><code>STORAGE</code> </td><td>no
</td></tr><tr><td><code>STYPE</code> </td><td>no
</td></tr><tr><td><code>SUPERUSER</code> </td><td>no
</td></tr><tr><td><code>TABLE</code> </td><td>yes
</td></tr><tr><td><code>TEXT</code> </td><td>no
</td></tr><tr><td><code>TIMESTAMP</code> </td><td>no
</td></tr><tr><td><code>TIMEUUID</code> </td><td>no
</td></tr><tr><td><code>THREE</code> </td><td>yes
</td></tr><tr><td><code>TOKEN</code> </td><td>yes
</td></tr><tr><td><code>TRUNCATE</code> </td><td>yes
</td></tr><tr><td><code>TTL</code> </td><td>no
</td></tr><tr><td><code>TWO</code> </td><td>yes
</td></tr><tr><td><code>TYPE</code> </td><td>no
</td></tr><tr><td><code>UPDATE</code> </td><td>yes
</td></tr><tr><td><code>USE</code> </td><td>yes
</td></tr><tr><td><code>USER</code> </td><td>no
</td></tr><tr><td><code>USERS</code> </td><td>no
</td></tr><tr><td><code>USING</code> </td><td>yes
</td></tr><tr><td><code>UUID</code> </td><td>no
</td></tr><tr><td><code>VALUES</code> </td><td>no
</td></tr><tr><td><code>VARCHAR</code> </td><td>no
</td></tr><tr><td><code>VARINT</code> </td><td>no
</td></tr><tr><td><code>WHERE</code> </td><td>yes
</td></tr><tr><td><code>WITH</code> </td><td>yes
</td></tr><tr><td><code>WRITETIME</code> </td><td>no
</td></tr><tr><td><code>DISTINCT</code> </td><td>no
</td></tr><tr><td><code>DATE</code> </td><td>no
</td></tr><tr><td><code>TIME</code> </td><td>no </td></tr></table><h2
id="appendixB">Appendix B: CQL Reserved Types</h2><p>The following type names
are not currently used by CQL, but are reserved for potential future use.
User-defined types may not use reserved type names as their
name.</p><table><tr><
th>type </th></tr><tr><td><code>byte</code>
</td></tr><tr><td><code>smallint</code> </td></tr><tr><td><code>complex</code>
</td></tr><tr><td><code>enum</code> </td></tr><tr><td><code>date</code>
</td></tr><tr><td><code>interval</code>
</td></tr><tr><td><code>macaddr</code>
</td></tr><tr><td><code>bitstring</code> </td></tr></table><h2
id="changes">Changes</h2><p>The following describes the changes in each version
of CQL.</p><h3 id="a3.3.0">3.3.0</h3><ul><li>User-defined functions are now
supported through <a href="#createFunctionStmt"><code>CREATE
FUNCTION</code></a> and <a href="#dropFunctionStmt"><code>DROP
FUNCTION</code></a>, </li><li>User-defined aggregates are now supported through
<a href="#createAggregateStmt"><code>CREATE AGGREGATE</code></a> and <a
href="#dropAggregateStmt"><code>DROP AGGREGATE</code></a>.</li><li>Allows
double-dollar enclosed strings literals as an alternative to single-quote
enclosed strings.</li></ul><h3 id="a3.2.0">3.2.0</h3><
ul><li>User-defined types are now supported through <a
href="#createTypeStmt"><code>CREATE TYPE</code></a>, <a
href="#alterTypeStmt"><code>ALTER TYPE</code></a>, and <a
href="#dropTypeStmt"><code>DROP TYPE</code></a></li><li><a
href="#createIndexStmt"><code>CREATE INDEX</code></a> now supports indexing
collection columns, including indexing the keys of map collections through the
<code>keys()</code> function</li><li>Indexes on collections may be queried
using the new <code>CONTAINS</code> and <code>CONTAINS KEY</code>
operators</li><li>Tuple types were added to hold fixed-length sets of typed
positional fields (see the section on <a href="#types">types</a>)</li><li><a
href="#dropIndexStmt"><code>DROP INDEX</code></a> now supports optionally
specifying a keyspace</li></ul><h3
id="a3.1.7">3.1.7</h3><ul><li><code>SELECT</code> statements now support
selecting multiple rows in a single partition using an <code>IN</code> clause
on combinations of clustering columns. See <a href="#select
Where">SELECT WHERE</a> clauses.</li><li><code>IF NOT EXISTS</code> and
<code>IF EXISTS</code> syntax is now supported by <code>CREATE USER</code> and
<code>DROP USER</code> statmenets, respectively.</li></ul><h3
id="a3.1.6">3.1.6</h3><ul><li>A new <a href="#uuidFun"><code>uuid</code>
method</a> has been added.</li><li>Support for <code>DELETE ... IF
EXISTS</code> syntax.</li></ul><h3 id="a3.1.5">3.1.5</h3><ul><li>It is now
possible to group clustering columns in a relatiion, see <a
href="#selectWhere">SELECT WHERE</a> clauses.</li><li>Added support for
<code>STATIC</code> columns, see <a href="#createTableStatic">static in CREATE
TABLE</a>.</li></ul><h3 id="a3.1.4">3.1.4</h3><ul><li><code>CREATE INDEX</code>
now allows specifying options when creating CUSTOM indexes (see <a
href="#createIndexStmt">CREATE INDEX reference</a>).</li></ul><h3
id="a3.1.3">3.1.3</h3><ul><li>Millisecond precision formats have been added to
the timestamp parser (see <a href="#usingtimestamps">working with
dates</a>).</li></ul><h3 id="a3.1.2">3.1.2</h3><ul><li><code>NaN</code> and
<code>Infinity</code> has been added as valid float contants. They are now
reserved keywords. In the unlikely case you we using them as a column
identifier (or keyspace/table one), you will noew need to double quote them
(see <a href="#identifiers">quote identifiers</a>).</li></ul><h3
id="a3.1.1">3.1.1</h3><ul><li><code>SELECT</code> statement now allows listing
the partition keys (using the <code>DISTINCT</code> modifier). See <a
href="https://issues.apache.org/jira/browse/CASSANDRA-4536";>CASSANDRA-4536</a>.</li><li>The
syntax <code>c IN ?</code> is now supported in <code>WHERE</code> clauses. In
that case, the value expected for the bind variable will be a list of whatever
type <code>c</code> is.</li><li>It is now possible to use named bind variables
(using <code>:name</code> instead of <code>?</code>).</li></ul><h3
id="a3.1.0">3.1.0</h3><ul><li><a href="#alterTableStmt">ALTER TABLE</a>
<code>DROP</code> o
ption has been reenabled for CQL3 tables and has new semantics now: the space
formerly used by dropped columns will now be eventually reclaimed
(post-compaction). You should not readd previously dropped columns unless you
use timestamps with microsecond precision (see <a
href="https://issues.apache.org/jira/browse/CASSANDRA-3919";>CASSANDRA-3919</a>
for more details).</li><li><code>SELECT</code> statement now supports aliases
in select clause. Aliases in WHERE and ORDER BY clauses are not supported. See
the <a href="#selectStmt">section on select</a> for
details.</li><li><code>CREATE</code> statements for <code>KEYSPACE</code>,
<code>TABLE</code> and <code>INDEX</code> now supports an <code>IF NOT
EXISTS</code> condition. Similarly, <code>DROP</code> statements support a
<code>IF EXISTS</code> condition.</li><li><code>INSERT</code> statements
optionally supports a <code>IF NOT EXISTS</code> condition and
<code>UPDATE</code> supports <code>IF</code> conditions.</li></ul><h3 id="a3.0.5
">3.0.5</h3><ul><li><code>SELECT</code>, <code>UPDATE</code>, and
<code>DELETE</code> statements now allow empty <code>IN</code> relations (see
<a
href="https://issues.apache.org/jira/browse/CASSANDRA-5626";>CASSANDRA-5626</a>).</li></ul><h3
id="a3.0.4">3.0.4</h3><ul><li>Updated the syntax for custom <a
href="#createIndexStmt">secondary indexes</a>.</li><li>Non-equal condition on
the partition key are now never supported, even for ordering partitioner as
this was not correct (the order was <strong>not</strong> the one of the type of
the partition key). Instead, the <code>token</code> method should always be
used for range queries on the partition key (see <a href="#selectWhere">WHERE
clauses</a>).</li></ul><h3 id="a3.0.3">3.0.3</h3><ul><li>Support for custom <a
href="#createIndexStmt">secondary indexes</a> has been added.</li></ul><h3
id="a3.0.2">3.0.2</h3><ul><li>Type validation for the <a
href="#constants">constants</a> has been fixed. For instance, the
implementation used to allow
<code>'2'</code> as a valid value for an <code>int</code> column
(interpreting it has the equivalent of <code>2</code>), or <code>42</code> as a
valid <code>blob</code> value (in which case <code>42</code> was interpreted as
an hexadecimal representation of the blob). This is no longer the case, type
validation of constants is now more strict. See the <a href="#types">data
types</a> section for details on which constant is allowed for which
type.</li><li>The type validation fixed of the previous point has lead to the
introduction of <a href="#constants">blobs constants</a> to allow inputing
blobs. Do note that while inputing blobs as strings constant is still supported
by this version (to allow smoother transition to blob constant), it is now
deprecated (in particular the <a href="#types">data types</a> section does not
list strings constants as valid blobs) and will be removed by a future version.
If you were using strings as blobs, you should thus update your client code
ASAP to
switch blob constants.</li><li>A number of functions to convert native types
to blobs have also been introduced. Furthermore the token function is now also
allowed in select clauses. See the <a href="#functions">section on
functions</a> for details.</li></ul><h3 id="a3.0.1">3.0.1</h3><ul><li><a
href="#usingtimestamps">Date strings</a> (and timestamps) are no longer
accepted as valid <code>timeuuid</code> values. Doing so was a bug in the sense
that date string are not valid <code>timeuuid</code>, and it was thus resulting
in <a href="https://issues.apache.org/jira/browse/CASSANDRA-4936";>confusing
behaviors</a>. However, the following new methods have been added to help
working with <code>timeuuid</code>: <code>now</code>, <code>minTimeuuid</code>,
<code>maxTimeuuid</code> , <code>dateOf</code> and
<code>unixTimestampOf</code>. See the <a href="#usingtimeuuid">section
dedicated to these methods</a> for more detail.</li><li>“Float
constants”#constants now support the expo
nent notation. In other words, <code>4.2E10</code> is now a valid floating
point value.</li></ul><h2 id="Versioning">Versioning</h2><p>Versioning of the
CQL language adheres to the <a href="http://semver.org";>Semantic Versioning</a>
guidelines. Versions take the form X.Y.Z where X, Y, and Z are integer values
representing major, minor, and patch level respectively. There is no
correlation between Cassandra release versions and the CQL language
version.</p><table><tr><th>version</th><th>description</th></tr><tr><td>Major
</td><td>The major version <em>must</em> be bumped when backward incompatible
changes are introduced. This should rarely occur.</td></tr><tr><td>Minor
</td><td>Minor version increments occur when new, but backward compatible,
functionality is introduced.</td></tr><tr><td>Patch </td><td>The patch
version is incremented when bugs are fixed.</td></tr></table></body></html>
[... 3 lines stripped ...]
