com.datastax.oss.driver.api.mapper.entity

Interface EntityHelper<EntityT>

public interface EntityHelper<EntityT>

A set of utility methods related to a particular mapped entity.

The mapper processor generates an implementation of this interface for each Entity-annotated class. It is used internally by other mapper components, and can also be injected in custom query providers.

Method Summary

Modifier and Type	Method and Description
Delete	deleteByPrimaryKey() Builds a delete query to delete an instance of the entity by primary key (partition key + clustering columns).
EntityT	get(GettableByName source) Gets values from a data structure to fill an entity instance.
Class<EntityT>	getEntityClass() The class of the mapped entity.
CqlIdentifier	getKeyspaceId() The keyspace used in the queries generated by this helper.
CqlIdentifier	getTableId() The table used in the queries generated by this helper.
RegularInsert	insert() Builds an insert query for this entity.
Select	selectByPrimaryKey() Builds a select query to fetch an instance of the entity by primary key (partition key + clustering columns).
Select	selectStart() Builds the beginning of a select query to fetch one or more instances of the entity.
<SettableT extends SettableByName<SettableT>> SettableT	set(EntityT entity, SettableT target, NullSavingStrategy nullSavingStrategy) Sets the properties of an entity instance into a target data structure.
Update	updateByPrimaryKey() Builds a Update query to update an instance of the entity by primary key (partition key + clustering columns).
Update	updateStart() Builds the beginning of a Update query to update an entity.

Method Detail

set

@NonNull
<SettableT extends SettableByName<SettableT>> SettableT set(@NonNull
                                                                     EntityT entity,
                                                                     @NonNull
                                                                     SettableT target,
                                                                     @NonNull
                                                                     NullSavingStrategy nullSavingStrategy)

Sets the properties of an entity instance into a target data structure.

For example:

 target = target.set("id", entity.getId(), UUID.class);
 target = target.set("name", entity.getName(), String.class);
 ...
 

The column names are inferred from the naming strategy for this entity.

Parameters:

entity - the entity that the values will be read from.

target - the data structure to fill. This will typically be one of the built-in driver subtypes: BoundStatement, BoundStatementBuilder or UdtValue. Note that the default BoundStatement implementation is immutable, therefore this argument won't be modified in-place: you need to use the return value to get the resulting structure.

Returns:

the data structure resulting from the assignments. This is useful for immutable target implementations (see above), otherwise it will be the same as target.

get

@NonNull
EntityT get(@NonNull
                     GettableByName source)

Gets values from a data structure to fill an entity instance.

For example:

 User returnValue = new User();
 returnValue.setId(source.get("id", UUID.class));
 returnValue.setName(source.get("name", String.class));
 ...
 

The column names are inferred from the naming strategy for this entity.

Parameters:

source - the data structure to read from. This will typically be one of the built-in driver subtypes: Row or UdtValue (BoundStatement and BoundStatementBuilder are also possible, although it's less likely that data would be read back from them in this manner).

Returns:

the resulting entity.

insert

@NonNull
RegularInsert insert()

Builds an insert query for this entity.

The returned query is roughly the equivalent of:

 QueryBuilder.insertInto(keyspaceId, tableId)
     .value("id", QueryBuilder.bindMarker("id"))
     .value("name", QueryBuilder.bindMarker("name"))
     ...
 

All mapped properties of the entity are included as bindable values (the bind markers have the same names as the columns).

The column names are inferred from the naming strategy for this entity.

The keyspace and table identifiers are those of the DAO that this helper was obtained from; if the DAO was built without a specific keyspace and table, the query doesn't specify a keyspace, and the table name is inferred from the naming strategy.

updateStart

@NonNull
Update updateStart()

Builds the beginning of a Update query to update an entity.

This is the same as updateByPrimaryKey() ()}, but without the WHERE clause. This would typically not be executed as-is, but instead completed with a custom WHERE clause (either added with the query builder DSL, or concatenated to the built query).

updateByPrimaryKey

@NonNull
Update updateByPrimaryKey()

Builds a Update query to update an instance of the entity by primary key (partition key + clustering columns).

The returned query is roughly the equivalent of:

 QueryBuilder.update(keyspaceId, tableId)
     .setColumn("description", QueryBuilder.bindMarker("description"))
     ... // (other non-PK columns)
     .where(Relation.column("id").isEqualTo(QueryBuilder.bindMarker("id"))
     ... // (other PK columns)
 

All non-PK properties of the entity are set, with bind markers that have the same names as the columns.

All components of the primary key are listed in the WHERE clause as bindable values (the bind markers have the same names as the columns). They are listed in the natural order, i.e. partition key columns first, followed by clustering columns (in the order defined by the PartitionKey and ClusteringColumn annotations on the entity class).

The keyspace and table identifiers are those of the DAO that this helper was obtained from; if the DAO was built without a specific keyspace and table, the query doesn't specify a keyspace, and the table name is inferred from the naming strategy.

selectByPrimaryKey

@NonNull
Select selectByPrimaryKey()

Builds a select query to fetch an instance of the entity by primary key (partition key + clustering columns).

The returned query is roughly the equivalent of:

 QueryBuilder.selectFrom(keyspaceId, tableId)
     .column("id")
     .column("name")
     .whereColumn("id").isEqualTo(QueryBuilder.bindMarker("id"));
   ...
 

All mapped properties of the entity are included in the result set.

All components of the primary key are listed in the WHERE clause as bindable values (the bind markers have the same names as the columns). They are listed in the natural order, i.e. partition key columns first, followed by clustering columns (in the order defined by the PartitionKey and ClusteringColumn annotations on the entity class).

The keyspace and table identifiers are those of the DAO that this helper was obtained from; if the DAO was built without a specific keyspace and table, the query doesn't specify a keyspace, and the table name is inferred from the naming strategy.

selectStart

@NonNull
Select selectStart()

Builds the beginning of a select query to fetch one or more instances of the entity.

This is the same as selectByPrimaryKey(), but without the WHERE clause. This would typically not be executed as-is, but instead completed with a custom WHERE clause (either added with the query builder DSL, or concatenated to the built query).

deleteByPrimaryKey

@NonNull
Delete deleteByPrimaryKey()

Builds a delete query to delete an instance of the entity by primary key (partition key + clustering columns).

The returned query is roughly the equivalent of:

 Delete delete = QueryBuilder.deleteFrom(keyspaceId, tableId)
     .whereColumn("id").isEqualTo(QueryBuilder.bindMarker("id"));
 

All components of the primary key are listed in the WHERE clause as bindable values (the bind markers have the same names as the columns). They are listed in the natural order, i.e. partition key columns first, followed by clustering columns (in the order defined by the PartitionKey and ClusteringColumn annotations on the entity class).

The keyspace and table identifiers are those of the DAO that this helper was obtained from; * if the DAO was built without a specific keyspace and table, the query doesn't specify a keyspace, and the table name is inferred from the naming strategy.

getKeyspaceId

@Nullable
CqlIdentifier getKeyspaceId()

The keyspace used in the queries generated by this helper.

This is determined by the following rules:

• If the DAO that this helper belongs to was created with a keyspace (see DaoKeyspace), use that;
• Otherwise, if Entity.defaultKeyspace() is set for the entity class, use that;
• Otherwise, return null.

getTableId

@NonNull
CqlIdentifier getTableId()

The table used in the queries generated by this helper.

This is determined by the following rules:

• If the DAO that this helper belongs to was created with a table (see DaoTable), use that;
• Otherwise, if the entity class is annotated with CqlName, use that;
• Otherwise, use the name of the entity class, transformed by its NamingStrategy.

getEntityClass

@NonNull
Class<EntityT> getEntityClass()

The class of the mapped entity.