= Definitions

== Conventions

To aid in specifying the CQL syntax, we will use the following
conventions in this document:

* Language rules will be given in an informal
http://en.wikipedia.org/wiki/Backus%E2%80%93Naur_Form#Variants[BNF
variant] notation. In particular, we'll use square brakets (`[ item ]`)
for optional items, `*` and `+` for repeated items (where `+` imply at
least one).
* The grammar will also use the following convention for convenience:
non-terminal term will be lowercase (and link to their definition) while
terminal keywords will be provided "all caps". Note however that
keywords are `identifiers` and are thus case insensitive in practice. We
will also define some early construction using regexp, which we'll
indicate with `re(<some regular expression>)`.
* The grammar is provided for documentation purposes and leave some
minor details out. For instance, the comma on the last column definition
in a `CREATE TABLE` statement is optional but supported if present even
though the grammar in this document suggests otherwise. Also, not
everything accepted by the grammar is necessarily valid CQL.
* References to keywords or pieces of CQL code in running text will be
shown in a `fixed-width font`.

[[identifiers]]
== Identifiers and keywords

The CQL language uses _identifiers_ (or _names_) to identify tables,
columns and other objects. An identifier is a token matching the regular
expression `[a-zA-Z][a-zA-Z0-9_]*`.

A number of such identifiers, like `SELECT` or `WITH`, are _keywords_.
They have a fixed meaning for the language and most are reserved. The
list of those keywords can be found in xref:cql/appendices.adoc#appendix-A[Appendix A].

Identifiers and (unquoted) keywords are case insensitive. Thus `SELECT`
is the same than `select` or `sElEcT`, and `myId` is the same than
`myid` or `MYID`. A convention often used (in particular by the samples
of this documentation) is to use uppercase for keywords and lowercase
for other identifiers.

There is a second kind of identifier called a _quoted identifier_
defined by enclosing an arbitrary sequence of characters (non-empty) in
double-quotes(`"`). Quoted identifiers are never keywords. Thus
`"select"` is not a reserved keyword and can be used to refer to a
column (note that using this is particularly ill-advised), while `select`
would raise a parsing error. Also, unlike unquoted identifiers
and keywords, quoted identifiers are case sensitive (`"My Quoted Id"` is
_different_ from `"my quoted id"`). A fully lowercase quoted identifier
that matches `[a-zA-Z][a-zA-Z0-9_]*` is however _equivalent_ to the
unquoted identifier obtained by removing the double-quote (so `"myid"`
is equivalent to `myid` and to `myId` but different from `"myId"`).
Inside a quoted identifier, the double-quote character can be repeated
to escape it, so `"foo "" bar"` is a valid identifier.

[NOTE]
.Note
====
The _quoted identifier_ can declare columns with arbitrary names, and
these can sometime clash with specific names used by the server. For
instance, when using conditional update, the server will respond with a
result set containing a special result named `"[applied]"`. If you’ve
declared a column with such a name, this could potentially confuse some
tools and should be avoided. In general, unquoted identifiers should be
preferred but if you use quoted identifiers, it is strongly advised that you
avoid any name enclosed by squared brackets (like `"[applied]"`) and any
name that looks like a function call (like `"f(x)"`).
====

More formally, we have:

[source, bnf]
----
include::example$BNF/identifier.bnf[]
----

[[constants]]
== Constants

CQL defines the following _constants_:

[source, bnf]
----
include::example$BNF/constant.bnf[]
----

In other words:

* A string constant is an arbitrary sequence of characters enclosed by
single-quote(`'`). A single-quote can be included by repeating it, e.g.
`'It''s raining today'`. Those are not to be confused with quoted
`identifiers` that use double-quotes. Alternatively, a string can be
defined by enclosing the arbitrary sequence of characters by two dollar
characters, in which case single-quote can be used without escaping
(`$$It's raining today$$`). That latter form is often used when defining
xref:cql/functions.adoc#udfs[user-defined functions] to avoid having to escape single-quote
characters in function body (as they are more likely to occur than
`$$`).
* Integer, float and boolean constant are defined as expected. Note
however than float allows the special `NaN` and `Infinity` constants.
* CQL supports
https://en.wikipedia.org/wiki/Universally_unique_identifier[UUID]
constants.
* Blobs content are provided in hexadecimal and prefixed by `0x`.
* The special `NULL` constant denotes the absence of value.

For how these constants are typed, see the xref:cql/types.adoc[Data types] section.

== Terms

CQL has the notion of a _term_, which denotes the kind of values that
CQL support. Terms are defined by:

[source, bnf]
----
include::example$BNF/term.bnf[]
----

A term is thus one of:

* A xref:cql/defintions.adoc#constants[constant]
* A literal for either a xref:cql/types.adoc#collections[collection],
a xref:cql/types.adoc#udts[user-defined type] or a xref:cql/types.adoc#tuples[tuple]
* A xref:cql/functions.adoc#cql-functions[function] call, either a xref:cql/functions.adoc#scalar-native-functions[native function]
or a xref:cql/functions.adoc#user-defined-scalar-functions[user-defined function]
* An xref:cql/operators.adoc#arithmetic_operators[arithmetic operation] between terms
* A type hint
* A bind marker, which denotes a variable to be bound at execution time.
See the section on `prepared-statements` for details. A bind marker can
be either anonymous (`?`) or named (`:some_name`). The latter form
provides a more convenient way to refer to the variable for binding it
and should generally be preferred.

== Comments

A comment in CQL is a line beginning by either double dashes (`--`) or
double slash (`//`).

Multi-line comments are also supported through enclosure within `/*` and
`*/` (but nesting is not supported).

[source,cql]
----
-- This is a comment
// This is a comment too
/* This is
   a multi-line comment */
----

== Statements

CQL consists of statements that can be divided in the following
categories:

* `data-definition` statements, to define and change how the data is
stored (keyspaces and tables).
* `data-manipulation` statements, for selecting, inserting and deleting
data.
* `secondary-indexes` statements.
* `materialized-views` statements.
* `cql-roles` statements.
* `cql-permissions` statements.
* `User-Defined Functions (UDFs)` statements.
* `udts` statements.
* `cql-triggers` statements.

All the statements are listed below and are described in the rest of
this documentation (see links above):

[source, bnf]
----
include::example$BNF/cql_statement.bnf[]
----

== Prepared Statements

CQL supports _prepared statements_. Prepared statements are an
optimization that allows to parse a query only once but execute it
multiple times with different concrete values.

Any statement that uses at least one bind marker (see `bind_marker`)
will need to be _prepared_. After which the statement can be _executed_
by provided concrete values for each of its marker. The exact details of
how a statement is prepared and then executed depends on the CQL driver
used and you should refer to your driver documentation.
