# CQL language reference for Amazon Keyspaces (for Apache Cassandra)
After you connect to an Amazon Keyspaces endpoint, you use Cassandra Query Language (CQL) to work with your database. CQL is similar in many ways to Structured Query Language (SQL).
+ **CQL elements** – This section covers the fundamental elements of CQL supported in Amazon Keyspaces, including identifiers, constants, terms, and data types. It explains concepts like string types, numeric types, collection types, and more.
+ **Data Definition Language (DDL)** – DDL statements are used to manage data structures like keyspaces and tables in Amazon Keyspaces. This section covers statements for creating, altering, and dropping keyspaces and tables, as well as restoring tables from a point-in-time backup.
+ **Data Manipulation Language (DML) ** – DML statements are used to manage data within tables. This section covers statements for selecting, inserting, updating, and deleting data. It also explains advanced querying capabilities like using the `IN` operator, ordering results, and pagination.
+ **Built-in functions** – Amazon Keyspaces supports a variety of built-in scalar functions that you can use in CQL statements. This section provides an overview of these functions, including examples of their usage.
Throughout this topic, you'll find detailed syntax, examples, and best practices for using CQL effectively in Amazon Keyspaces.
**Topics**
+ [Cassandra Query Language (CQL) elements in Amazon Keyspaces](cql.elements.md)
+ [DDL statements (data definition language) in Amazon Keyspaces](cql.ddl.md)
+ [DML statements (data manipulation language) in Amazon Keyspaces](cql.dml.md)
+ [Built-in functions in Amazon Keyspaces](cql.functions.md)
# Cassandra Query Language (CQL) elements in Amazon Keyspaces
Learn about the Cassandra Query Language (CQL) elements that are supported by Amazon Keyspaces, including identifiers, constants, terms, and data types.
**Topics**
+ [identifier](#cql.elements.identifier)
+ [constants](#cql.elements.constants)
+ [term](#cql.elements.term)
+ [Data types](#cql.data-types)
+ [JSON encoding of Amazon Keyspaces data types](#cql.data-types.JSON)
## Identifiers
Identifiers (or names) are used to identify tables, columns, and other objects. An identifier can be quoted or not quoted. The following applies.
```
identifier ::= unquoted_identifier | quoted_identifier
unquoted_identifier ::= re('[a-zA-Z][a-zA-Z0-9_]*')
quoted_identifier ::= '"' (any character where " can appear if doubled)+ '"'
```
## Constants
The following constants are defined.
```
constant ::= string | integer | float | boolean | uuid | blob | NULL
string ::= '\'' (any character where ' can appear if doubled)+ '\''
'$$' (any character other than '$$') '$$'
integer ::= re('-?[0-9]+')
float ::= re('-?[0-9]+(\.[0-9]*)?([eE][+-]?[0-9+])?') | NAN | INFINITY
boolean ::= TRUE | FALSE
uuid ::= hex{8}-hex{4}-hex{4}-hex{4}-hex{12}
hex ::= re("[0-9a-fA-F]")
blob ::= '0' ('x' | 'X') hex+
```
## Terms
A term denotes the kind of values that are supported. Terms are defined by the following.
```
term ::= constant | literal | function_call | arithmetic_operation | type_hint | bind_marker
literal ::= collection_literal | tuple_literal
function_call ::= identifier '(' [ term (',' term)* ] ')'
arithmetic_operation ::= '-' term | term ('+' | '-' | '*' | '/' | '%') term
```
## Data types
Amazon Keyspaces supports the following data types:
### String types
****
| Data type | Description |
| --- | --- |
| `ascii` | Represents an ASCII character string. |
| `text` | Represents a UTF-8 encoded string. |
| `varchar` | Represents a UTF-8 encoded string (`varchar` is an alias for `text`). |
### Numeric types
****
| Data type | Description |
| --- | --- |
| `bigint` | Represents a 64-bit signed long. |
| `counter` | Represents a 64-bit signed integer counter. For more information, see [Counters](#cql.data-types.numeric.counters). |
| `decimal` | Represents a variable-precision decimal. |
| `double` | Represents a 64-bit IEEE 754 floating point. |
| `float` | Represents a 32-bit IEEE 754 floating point. |
| `int` | Represents a 32-bit signed int. |
| `varint` | Represents an integer value within the \$1/-10^38 range. |
#### Counters
A `counter` column contains a 64-bit signed integer. The counter value is incremented or decremented using the [UPDATE](cql.dml.update.md) statement, and it cannot be set directly. This makes `counter` columns useful for tracking counts. For example, you can use counters to track the number of entries in a log file or the number of times a post has been viewed on a social network. The following restrictions apply to `counter` columns:
+ A column of type `counter` cannot be part of the `primary key` of a table.
+ In a table that contains one or more columns of type `counter`, all columns in that table must be of type `counter`.
In cases where a counter update fails (for example, because of timeouts or loss of connection with Amazon Keyspaces), the client doesn't know whether the counter value was updated. If the update is retried, the update to the counter value might get applied a second time.
### Blob type
****
| Data type | Description |
| --- | --- |
| `blob` | Represents arbitrary bytes. |
### Boolean type
****
| Data type | Description |
| --- | --- |
| `boolean` | Represents true or false. |
### Time-related types
****
| Data type | Description |
| --- | --- |
| `date` | A string in the format --. |
| `timestamp` | 64-bit signed integer representing the date and time since epoch (January 1 1970 at 00:00:00 GMT) in milliseconds. |
| `timeuuid` | Represents a [version 1 UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)). |
### Collection types
****
| Data type | Description |
| --- | --- |
| `list` | Represents an ordered collection of literal elements. |
| `map` | Represents an unordered collection of key-value pairs. |
| `set` | Represents an unordered collection of one or more literal elements. |
You declare a collection column by using the collection type followed by another data type (for example, `TEXT` or `INT`) in angled brackets. You can create a column with a `SET` of `TEXT`, or you can create a `MAP` of `TEXT` and `INT` key-value pairs, as shown in the following example.
```
SET
MAP
```
A *non-frozen* collection allows you to make updates to each individual collection element. Client-side timestamps and Time to Live (TTL) settings are stored for individual elements.
When you use the `FROZEN` keyword on a collection type, the values of the collection are serialized into a single immutable value, and Amazon Keyspaces treats them like a `BLOB`. This is a *frozen* collection. An `INSERT` or `UPDATE` statement overwrites the entire frozen collection. You can't make updates to individual elements inside a frozen collection.
Client-side timestamps and Time to Live (TTL) settings apply to the entire frozen collection, not to individual elements. `Frozen` collection columns can be part of the `PRIMARY KEY` of a table.
You can nest frozen collections. For example, you can define a `MAP` within a `SET` if the `MAP` is using the `FROZEN` keyword, as shown in the following example.
```
SET