public interface CassDataTypes
In a relational database, you must specify a data type for each column when you define a table. The data type constrains the values that can be inserted into that column. For example, if you have a column defined as an integer datatype, you would not be allowed to insert character data into that column. Column names in a relational database are typically fixed labels (strings) that are assigned when you define the table schema.
In Cassandra, the data type for a column (or row key) value is called a validator. The data type for a column name is called a comparator. You can define data types when you create your column family schemas (which is recommended), but Cassandra does not require it. Internally, Cassandra stores column names and values as hex byte arrays (BytesType). This is the default client encoding used if data types are not defined in the column family schema (or if not specified by the client request).
Cassandra comes with the following built-in data types, which can be used as both validators (row key and column value data types) or comparators (column name data types). One exception is CounterColumnType, which is only allowed as a column value (not allowed for row keys or column names).
For all column families, it is best practice to define a default row key validator using the key_validation_class property.
For static column families, you should define each column and its associated type when you define the column family using the column_metadata property.
For dynamic column families (where column names are not known ahead of time), you should specify a default_validation_class instead of defining the per-column data types.
Key and column validators may be added or changed in a column family definition at any time. If you specify an invalid validator on your column family, client requests that respect that metadata will be confused, and data inserts or updates that do not conform to the specified validator will be rejected.
Within a row, columns are always stored in sorted order by their column name. The comparator specifies the data type for the column name, as well as the sort order in which columns are stored within a row. Unlike validators, the comparator may not be changed after the column family is defined, so this is an important consideration when defining a column family in Cassandra.
Typically, static column family names will be strings, and the sort order of columns is not important in that case. For dynamic column families, however, sort order is important. For example, in a column family that stores time series data (the column names are timestamps), having the data in sorted order is required for slicing result sets out of a row of columns.
| Modifier and Type | Interface and Description |
|---|---|
static class |
CassDataTypes.BasicType
Basic data type.
|
static class |
CassDataTypes.CompositeType
Composite type.
|
| Modifier and Type | Method and Description |
|---|---|
String |
getTypeClass()
Gets the name of the type class to use in a Cassandra configuration
command.
|
String getTypeClass()
Copyright © 2015. All Rights Reserved.