cassandra-driver-mapping

Features

The features provided by the module include:

• Object Mapper

  • Get, Save, Delete entity. (Synchronous and Asynchronous).
  • Update individual value. (Synchronous and Asynchronous).
  • Batch Save/Delete. (Synchronous and Asynchronous).
  • Run and Map custom Queries and ResultSets.
  • Versioning and Optimistic Concurrency control.
  • Direct Collections Modifications

• Schema Sync

  • Automatically create table and indexes from Entity.
  • Automatically Alter table and indexes if entity definition has changed.
  • Drop table.
  • Generate Script.

Jump Start

• Maven Dependency.
  Install in your application from Maven Central using the following dependency:

  <dependency>
    <groupId>com.valchkou.datastax</groupId>
    <artifactId>cassandra-driver-mapping</artifactId>
    <version>3.0.0</version>
  </dependency>

  All new changes and bugfixes are released within the latest version as soon as coded. Module versioning policy matches underlying datastax driver core versioning.

• Init Mapping Session.
  MappingSession is cheap to instantiate and it is not replacement for the Datastax Session.
  You can instantiate as many mapping sessions as you want. It's threadsafe.

  import com.datastax.driver.core.Session;
  import com.datastax.driver.mapping.MappingSession;
  ...
  
  Session session; // initialize datastax session.
  MappingSession mappingSession = new MappingSession("keyspace_name", session);

• Save.

  Entity entity = new Entity();
  mappingSession.save(entity);

• Get.

  Entity entity = mappingSession.get(Entity.class, id);

• Delete.

  mappingSession.delete(entity);  

• To Sync or not to Sync.

Synchronization is a cool feature but you can completely or partially disable it using SyncOptions.
Supported SyncOptions are: DoNotSync, DoNotAddColumns, DoNotDropColumns.
SyncOptions can be set for all or specific entities as shown below:

    /** Turn synchronization with C* off: */
    SyncOptions syncOptions = SyncOptions.withOptions().doNotSync());

    /** Turn synchronization off for specific Entity */
    SyncOptions syncOptions = SyncOptions.withOptions().doNotSync(Entity1.class);

    /** Turn synchronization with C* off except specific Entity: */
    SyncOptions syncOptions = SyncOptions.withOptions().doNotSync().doSync(Entity1.class);

    /** 
     *  Do not add or drop columns for Entities.   
     *  This will not affect initial synchronization when Table is created for the first time. 
     */
    SyncOptions syncOptions = SyncOptions.withOptions().add(SyncOptionTypes.DoNotAddColumns);
    SyncOptions syncOptions = SyncOptions.withOptions().add(SyncOptionTypes.DoNotAddColumns).add(SyncOptionTypes.DoNotDropColumns);
    SyncOptions syncOptions = SyncOptions.withOptions().add(Entity1.class, SyncOptionTypes.DoNotDropColumns);

Pass SyncOptions into the MappingSession

    /** Constractor */
    MappingSession mappingSession = new MappingSession("keyspace_name", session, syncOptions);

    /** Setter */
    mappingSession.setSyncOptions(syncOptions);

Mapping Session API

Write

• Synchronous.

  
  /** Persist Entity */
  save(entity);
  
  /** Persist Entity with WriteOptions*/
  save(entity, writeOptions);
  
  /** Remove an item or items from the Set or List. */
  remove(id, Entity.class, propertyName, item);
  
  /** Append value to the Set, List or Map. Value can be a single value, a List, Set or a Map. */
  append(id, Entity.class, propertyName, value);
  
  /** Append value to the Set, List or Map with WriteOptions. Value can be a single value, a List, Set or a Map. */
  append(id, Entity.class, propertyName, value, writeOptions);
  
  /** Save Individual Value. */
  updateValue(id, Entity.class, propertyName, value);
  
  /** Save Individual Value with WriteOptions. */
  updateValue(id, Entity.class, propertyName, value, writeOptions);
  
  /** Place value at the beginning of the List. 
   *  Value can be a single value or a List. */
  prepend(id, Entity.class, propertyName, value);
  
  /** Place value at the beginning of the List with WriteOptions. 
   *  Value can be a single value or a List. */
  prepend(id, Entity.class, propertyName, value, writeOptions);
  
  /** Replace item at the specified position in the List. */
  replaceAt(id, Entity.class, propertyName, item, index);
  
  /** Replace item at the specified position in the List with WriteOptions. */
  replaceAt(id, Entity.class, propertyName, item, index, writeOptions);

- Asynchronous.  
All async methods run by datastax session.executeasync() and Datastax ResultSetFuture is returned.
```java

    /** Asynchronously Persist Entity */
    saveAsync(entity);

    /** Asynchronously Persist Entity with WriteOptions */
    saveAsync(entity, writeOptions);    

    /** Asynchronously Remove an item or items from the Set or List. */
    removeAsync(id, Entity.class, propertyName, item);

    /** Asynchronously Append value to the Set, List or Map. Value can be a single value, a List, Set or a Map. */
    appendAsync(id, Entity.class, propertyName, value);

    /** Asynchronously Append value to the Set, List or Map with WriteOptions. Value can be a single value, a List, Set or a Map. */
    appendAsync(id, Entity.class, propertyName, value, writeOptions);

    /** Asynchronously Save Individual Value. */
    updateValueAsync(id, Entity.class, propertyName, value);

    /** Asynchronously Save Individual Value with WriteOptions. */
    updateValueAsync(id, Entity.class, propertyName, value, writeOptions);

    /** Asynchronously Place value at the beginning of the List. 
     *  Value can be a single value or a List. */
    prependAsync(id, Entity.class, propertyName, value);

    /** Asynchronously Place value at the beginning of the List with WriteOptions. 
     *  Value can be a single value or a List. */
    prependAsync(id, Entity.class, propertyName, value, writeOptions);

    /** Asynchronously Replace item at the specified position in the List. */
    replaceAtAsync(id, Entity.class, propertyName, item, index);

    /** Asynchronously Replace item at the specified position in the List with WriteOptions. */
    replaceAtAsync(id, Entity.class, propertyName, item, index, writeOptions);

• Write Options.
  Save/Upate methods accept "WriteOptions" argument.
  Supported write options are: ConsistencyLevel, RetryPolicy, Timestamp, TTL.
  Examples:

  import com.datastax.driver.mapping.option.WriteOptions;
  import com.datastax.driver.core.policies.DefaultRetryPolicy;
  import com.datastax.driver.core.ConsistencyLevel;
  ...
  // create options
  WriteOptions options = new WriteOptions()
      .setTtl(300)
      .setTimestamp(42)
      .setConsistencyLevel(ConsistencyLevel.ANY)
      .setRetryPolicy(DefaultRetryPolicy.INSTANCE);
  
  Entity entity = new Entity();
  entity = mappingSession.save(entity, options);

  import com.datastax.driver.mapping.option.WriteOptions;
  ...
  Entity entity = new Entity();
  ResultSetFuture f = mappingSession.saveValueAsync(entity, new WriteOptions().setTtl(300));

• Collections Samples.
  You can work with your collection properties as you would normally work with other entity properties.
  In addition C provides optimized operations on collections. Those operations do not require to load and save the whole entity. C allows us directly manipulate collections.

• List operations

  
  // append item to list
  mappingSession.append(id, Entity.class, "cats", "Black Cat");

// append item to be expired in 5 sec mappingSession.append(id, Entity.class, "cats", "Expired Cat", new WriteOptions().setTtl(5));

// prepend item mappingSession.prepend(id, Entity.class, "cats", "First Cat");

// replace item at specified index mappingSession.replaceAt(id, Entity.class, "cats", "Grey Cat", 1);

// append List of items List addCats = new ArrayList(); addCats.add("Red Cat"); addCats.add("Green Cat"); mappingSession.append(id, Entity.class, "cats", addCats);

// remove item mappingSession.remove(id, Entity.class, "cats", "Grey Cat");

// remove List of items List removeCats = new ArrayList(); removeCats.add("Red Cat"); removeCats.add("Green Cat"); mappingSession.remove(id, Entity.class, "cats", removeCats);

// remove all items mappingSession.deleteValue(id, Entity.class, "cats");

<a name="collections_set"/>
- Set operations
```java
// append item
mappingSession.append(id, Entity.class, "dogs", "Black Dog");

// append item to be expired in 5 sec
mappingSession.append(id, Entity.class, "dogs", "Expired Dog", new WriteOptions().setTtl(5));

// append Set of items
Set<String> addDogs = new HashSet<String>();
addDogs.add("Red Dog");
addDogs.add("Green Dog");
mappingSession.append(id, Entity.class, "dogs", addDogs);

// remove item
mappingSession.remove(id, Entity.class, "dogs", "Black Dog");

// remove Set of items
Set<String> removeDogs = new HashSet<String>();
removeDogs.add("Red Dog");
removeDogs.add("Green Dog");
mappingSession.remove(id, Entity.class, "dogs", removeDogs);

// remove all items
mappingSession.deleteValue(id, Entity.class, "dogs");

• Map operations

  
  /** append item */
  Map<String, BigInteger> pets = new HashMap<String, BigInteger>();
  pets.put("Red Dogs", 25);
  pets.put("Black Cats", 50);
  mappingSession.append(id, Entity.class, "pets", pets);

/* append items to be expired in 5 sec / Map<String, BigInteger> pets = new HashMap<String, BigInteger>(); pets.put("Green Dogs", 25); pets.put("Brown Cats", 50); mappingSession.append(id, Entity.class, "pets", pets, new WriteOptions().setTtl(5));

/* remove all items / mappingSession.deleteValue(id, Entity.class, "pets");

<a name="read"/>
#### Read

```java
    /** Get Entity by Id(Primary Key) */
    Entity e = mappingSession.get(Entity.class, id);

    /** Get Entity by Id(Primary Key) with Options */
    Entity e = mappingSession.get(Entity.class, id, readOptions);

    /** Get Collection of Entities by custom Query Statement  */
    List<Entity> list = mappingSession.getByQuery(Entity.class,  queryStatement);

    /** Get Collection of Entities by custom Query String  */
    List<Entity> list = mappingSession.getByQuery(Entity.class,  queryString);

    /** Convert custom ResultSet into Collection of Entities */
    List<Entity> list = mappingSession.getFromResultSet(Entity.class, resultSet);

    /** Convert Row of ResultSet into Entity instance. */
    Entity e =  mappingSession.getFromRow(Entity.class, row);

    /** Convert Rows of ResultSet into Collection of Entities. */
    List<Entity> list = mappingSession.getFromRows(Entity.class, rows);

• Supported Read Options: ConsistencyLevel, RetryPolicy:

  import com.datastax.driver.mapping.option.ReadOptions;
  import com.datastax.driver.core.policies.DefaultRetryPolicy;
  import com.datastax.driver.core.ConsistencyLevel;
  ...
  // using options
  ReadOptions options = new ReadOptions()
      .setConsistencyLevel(ConsistencyLevel.ANY)
      .setRetryPolicy(DefaultRetryPolicy.INSTANCE);
  
  Entity entity = mappingSession.get(Entity.class, id, options);

• Custom Queries.
  This section describes how to use your Custom Queries with the Mapping Module.
  There are two ways to run and map Custom Query

1) run using mapping session

import com.datastax.driver.mapping.MappingSession;
...
List<Entity> result = mappingSession.getByQuery(Entity.class, query);

2) run using DataStax session and map the ResultSet

import com.datastax.driver.core.Session;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.mapping.MappingSession;
...
ResultSet rs = session.execute(query);  
List<Entity> result = mappingSession.getFromResultSet(Entity.class, rs);

Section below describes how you can build Custom Queries.

• CQL String

  import com.datastax.driver.mapping.MappingSession;
  ... 
  
  // build query
  String query = "SELECT name, age, birth_date, salary FROM person"); 
  
  // run query                        
  List<Entity> result = mappingSession.getByQuery(Entity.class, query);   

• QueryBuilder (Better)
  Datastax Driver shipped with a tool to build CQL statement.
  You can build your query with Datastax QueryBuilder and map ResultSet on Entity.
  QueryBuilder ensures you build correct CQL.

  
  import com.datastax.driver.core.Statement;
  import com.datastax.driver.core.querybuilder.QueryBuilder;
  import com.datastax.driver.mapping.MappingSession;
  ...
  
  // build query
  Statement query = QueryBuilder.select().all().from("your_keyspace", "your_table").where(eq("column", value));
  
  // run query                        
  List<Entity> result = mappingSession.getByQuery(Entity.class, query);

• QueryBuilder with EntityMetadata (Even Better)
  In early stages you may often change table and column names.
  To avoid changing queries each time you rename something you can employ entity metadata.

  import com.datastax.driver.core.Statement;
  import com.datastax.driver.core.querybuilder.QueryBuilder;
  import com.datastax.driver.mapping.MappingSession;
  import com.datastax.driver.mapping.EntityFieldMetaData;
  import com.datastax.driver.mapping.EntityTypeMetadata;  
  ...         
  
  // get Entity Metadata
  EntityTypeMetadata emeta = EntityTypeParser.getEntityMetadata(Entity.class);
  
  // get field metadata by property/field name
  EntityFieldMetaData fmeta = emeta.getFieldMetadata(field_name); 
  
  // build query.
  Statement query = QueryBuilder.select().all()
      .from("your_keyspace", emeta.getTableName()).where(eq(fmeta.getColumnName(), value));
  
  // run query
  List<Entity> result = mappingSession.getByQuery(Entity.class, query);

• Any-to-Any and Magic Gnomes
  This is the coolest feature of the module. Your Entity doesn't have to match the table.
  You can populate any entity from any query (Any-to-Any).
  Consider example:

  public class AnyObject {
      private String name;
      private int age;
      // public getters/setters ...
  }

  You can populate this object from any ResultSet which contains 'name' and 'age' columns.

  ResultSet rs = session.execute("SELECT name, age, birth_date, salary FROM person"); 
  List<AnyObject> result = mappingSession.getFromResultSet(AnyObject.class, rs);

  In this particular case 'name' and 'age' will be populated on 'AnyObject'. 'birth_date' and 'salary' will be ignored and no errors will be thrown.
  The biggest advantage that we can reuse the same entity to query different results from even different tables. Entity doesn't have to map, match or relate to the table at all. Many thank to magic gnomes under the hood making all these work.

Delete

    /** Delete Entity  */
    delete(entity);

    /** Delete Entity by ID(Primary key) */
    delete(Entity.class, id);

    /** Asynchronously delete Entity  */
    deleteAsync(entity);

    /** Asynchronously Delete Entity by ID(Primary key) */
    deleteAsync(Entity.class, id);

    /** Delete Individual Value */
    deleteValue(id, Entity.class, propertyName);

    /** Asynchronously Delete Individual Value */
    deleteValueAsync(id, Entity.class, propertyName);

Batch

    mappingSession.withBatch()
        .save(entityA)
        .save(entityB, writeOptions)
        .delete(entityD)
        .execute();

    ResultSetFuture f = mappingSession.withBatch()
        .save(entityA)
        .save(entityB, writeOptions)
        .delete(entityD)
        .executeAsync();

Various Mappings

IMPORTANT!!!  
- Each persistant field MUST have publlic Getter/Setter.
- If entity or field is not annotated it will provide its name as default.    
- Id field is required and must be annotated with @Id or @EmbeddedId.
- Index name must be unique within the keyspace.  
- C* supports only single-column-index.

Basic Mapping

import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Column

@Table (name="mytable")
public class Entity {

    @Id
    private long Id;

    @Column(name = "myname")
    private String name;

    // @Column is not required
    private int age;

    @Transient
    private BigDecimal calculable;

    // public getters/setters ...
}

CQL3 Statement

   CREATE TABLE IF NOT EXISTS ks.mytable (id bigint, myname text, age int, PRIMARY KEY(id))

Mapping Indexes

import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Column
import javax.persistence.Index
import java.util.UUID

@Table (name="mytable", 
indexes = {
    @Index(name="entity_email_idx", columnList="email" ), 
    @Index(name="entity_name_idx", columnList="myname" ) 
})
public class Entity {

    @Id
    private java.util.UUID code;

    @Column(name = "myname")
    private String name;
    private String email;
    // public getters/setters ...
}

CQL3 Statement

    CREATE TABLE IF NOT EXISTS ks.mytable (code uuid, myname text, email text,  PRIMARY KEY(code)); 
    CREATE INDEX IF NOT EXISTS entity_email_idx ON ks.mytable(email);  
    CREATE INDEX IF NOT EXISTS entity_name_idx ON ks.mytable(myname);

Compound Primary Key

public class CompositeKey {
    private String name;
    private int rank;
    // public getters/setters ...
}

import javax.persistence.Table;
import javax.persistence.EmbeddedId;    

@Table(name="entity")
public class Entity {
    @EmbeddedId
    private CompositeKey key;
    private String email;
    // public getters/setters ...
}

CQL3 Statement

   CREATE TABLE IF NOT EXISTS ks.entity (name text,  rank int, email text,  PRIMARY KEY(name, rank))

Composite Partition Key

public class PartitionKey {
    private String firstName;
    private String lastName;
    // public getters/setters ...
}

public class CompositeKey {
    @EmbeddedId
    private PartitionKey key;
    private int age;
    // public getters/setters ...
}

import javax.persistence.Table;
import javax.persistence.EmbeddedId;    

@Table(name="entity")
public class Entity {
    @EmbeddedId
    private CompositeKey key;
    private String email;
    // public getters/setters ...
}

CQL3 Statement

   CREATE TABLE IF NOT EXISTS ks.entity (firstname text, lastname text, age int, email text,  PRIMARY KEY((firstname, lastname), age))

Table Properties

Mixed Case for Column Names

Collections

Collections must have generic type defined. Only java.util.List, Map and Set are allowed.
By default implementation of HashMap, HashSet and ArrayList are used.

@Table (name="entity")
public class Entity {
    ...
    private List<String> cats;
    private Set<Date> dogs;
    private Map<String, BigInteger> pets;
    ...
}

If you are unhappy with defaults and would like your data to be baked with specific collection implementation you can apply an annotation as shown below.
NOTE: this is strictly java side feature and does not effect how your data stored in C*.

import com.datastax.driver.mapping.annotation.CollectionType;
    ...
@Table (name="entity")
public class Entity {
    ...
    @CollectionType(LinkedList.class)
    private List<String> cats;

    @CollectionType(TreeSet.class)
    private Set<Date> dogs;

    @CollectionType(TreeMap.class)
    private Map<String, BigInteger> pets;
    ...
}

CQL3 Statement

   CREATE TABLE IF NOT EXISTS ks.entity (id uuid, cats list<text>, dogs set<timestamp>, pets map<text, varint>,  PRIMARY KEY(id))

TTL

import com.datastax.driver.mapping.annotation.Ttl;
...
@Ttl(300) // expires in 5 minutes
@Table (name="mytable")
public class Entity {
   ...
}

Static columns

ID, UUID and TimeUUID.

uuid and timeuuid are often used in Primary Key.
This section describes few important features working with uuid type.

• Declare uuid and timeuuid properties.

  private UUID someUuid;
  
  @Column(columnDefinition="timeuuid")
  private UUID someTimeuuid;    

• Autogenerate uuid & timeuuid.
  This approach delegates generate and set uuid and timeuui property to C* itself.
  All you need is annotate an id property with JPA annotation @GeneratedValue.

  @GeneratedValue
  private UUID someUuid;
  
  @GeneratedValue
  @Column(columnDefinition="timeuuid")
  private UUID someTimeuuid;    

  If uuid or timeuuid are NULL on insert the Mapping Module will build CQL with uuid() or now() functions respectively.
  The drowback of this approach that CQL does not return generated id back.
  It means when you do obj = save(obj) the obj will not have its uuid set though it will be set in C*.
  This approach works fine for write-and-forget. But in case you need to know id you have to set it manually.

• uuid.

  UUID id = UUID.randomUUID();

• timeuuid

  
  import com.datastax.driver.core.utils.UUIDs;
  import java.util.UUID;

UUID id = UUIDs.timeBased();

- Convert timeuuid to date
```java
import java.util.Date;
import java.util.UUID;
import com.datastax.driver.core.utils.UUIDs;

public class DateUtil {
    public static Date timeUUID2Date(UUID uuid) {
        long time = UUIDs.unixTimestamp(uuid);
        return new Date(time);
    }
}

Optimistic Lock

• @Version
  Mapping Add-on enables optimistic locking using annotation @Version.
  The property must be of "long" data type. Whenever you save entity the version get incremented and as result of operation updated entity is retirned. If you try to save not-the-latest one then "null" will be returned instead and no error will be thrown.

  
  import javax.persistence.Id;
  import javax.persistence.Table;
  import javax.persistence.Version;   
  
  @Table(name="entity")
  public class EntityWithVersion {
      @Id
      private java.util.UUID id;
  
      @Version
      private long version;   
      // public getters/setters ...
  }
  
  @Test
  public void entityWithVersionTest() throws Exception {
      UUID id = UUID.randomUUID();
      EntityWithVersion obj = new EntityWithVersion();
      obj.setId(id);
      obj.setName("ver1"); 
  
      EntityWithVersion loaded = mappingSession.get(EntityWithVersion.class, id);
      assertNull(loaded);
  
      // save object ver1 
      EntityWithVersion saved = mappingSession.save(obj);
  
      // get object ver1
      EntityWithVersion obj1 = mappingSession.get(EntityWithVersion.class, id);
      assertEquals(obj1, saved);
      assertEquals(1, saved.getVersion());
  
      // save object ver2
      saved = mappingSession.save(saved);
      EntityWithVersion obj2 = mappingSession.get(EntityWithVersion.class, id);
      assertEquals(obj2, saved);
      assertEquals(2, saved.getVersion());        
  
      saved = mappingSession.save(obj1);
      assertNull(saved);
  }       

Nested Entities

Cussandra does not support nested entities nor it has integrity constraints. So there is no automatic support for nested entities. This Section describes how you can support Nested entities manually.

    @Table(name="entity_a")
    public class EntityA {
        @Id
        private UUID id;

        // public getters/setters ...
    }

    @Table(name="entity_b")
    public class EntityB {
        @Id
        private UUID id;

        // reference on EntityA 
        private UUID refA;
        // public getters/setters ...
    }   

    public class TestNested() {

        @Test
        public void saveNested() throws Exception {
            EntityA a = new EntityA();
            mappingSession.save(a);

            EntityB b = new EntityB();
            b.setRefA(a.getId());
            mappingSession.save(b);
        }

        @Test
        public void loadNested() throws Exception {
            UUID bId = some_id;
            EntityB b = mappingSession.load(bId);
            EntityA a = mappingSession.load(b.getRefA());
        }

    }

Under The Hood

Prepared Statement Cache

For the performance gain most update/select/delete statements are built as Prepared Statements. Prepared Statements are reusable and placed in the static cache. Cache is Guava Cache implementation initialized as:

.expireAfterAccess(5, TimeUnit.MINUTES)
.maximumSize(1000)
.concurrencyLevel(4)

If you want to tune the cache for better performance you can do it as:

Cache<String, PreparedStatement> cache = CacheBuilder
    .newBuilder()
    .expireAfterAccess(60, TimeUnit.MINUTES)
    .maximumSize(10000)
    .concurrencyLevel(8)
    .build();

MappingSession.setStatementCache(cache);

How Entity get synchronized

The table structure is automatically synchronized with the entity definition on the first use of the entity.
Any SessionMapping call internally will check if the entity has already been synchronized and if not
it will run SchemaSync.sync. You can use sync API directly as:

    // create or alter
    import com.datastax.driver.mapping.schemasync.SchemaSync;
    ...
    SchemaSync.sync(keyspace, session, Entity.class);

    // drop table
    import com.datastax.driver.mapping.schemasync.SchemaSync;
    ...
    SchemaSync.drop(keyspace, session, Entity.class);

// get CQL script which will be generated and run
import com.datastax.driver.mapping.schemasync.SchemaSync;
...
String script = SchemaSync.getScript(keyspace_name, datastax_session,  Entity.class);

// get CQL script which will be generated and run
import com.datastax.driver.mapping.schemasync.SchemaSync;
...
String script = SchemaSync.getScript(keyspace_name, datastax_session,  Entity.class);

You don't need to use this API unless you have reasons.
Such as unittests or if you want to gain few milliseconds on the first use
you may want to invoke the synchronization on the application start up instead.

As the project is evolving sometimes there is need to refactor entity, add or delete properties and indexes. Again this all taken care automatically but with certain restrictions.
Please read to understand what will and will not be altered and synchronized.

Not Alterable

• add/delete/rename primary key columns. (C* restriction)
• change column data type to incompatible one, such as string to number. (C* restriction)
• change property name which is not annotated as @Column. This will be understood as a new property.
• Table Properties (@TableProperties). There is no consistent way to compare with existing properties.

Alterable

• add new property.
• delete property.
• add index on column.
• change datatype to compatible one. Compatibility is enforced by C*.

Entity Metadata and Data Types

You may want to access Entity metadata if you are building custom Statements.
Entity Metadata contains corresponding table and column names.
Entity Metadata can be easily accessed anywhere in your code as:

    EntityTypeMetadata emeta = EntityTypeParser.getEntityMetadata(Entity.class)
    emeta.getTableName(); // corresponding table name in C*

    // get field meta info by property name
    EntityFieldMetaData fdata = emeta.getFieldMetadata("email");

    // corresponding column name in C*
    String columnName = fdata.getColumnName(); 

     // all the persistent fields on entity
    List<EntityFieldMetaData> fields = emeta.getFields();

My Mapper vs Datastax Mapper

Both mappers built on top of Datastax Java Driver and introduce Object Mapper layer for simplicity. There are few common features and differences.

The biggest difference is that datastax mapper does not generate schema for you automatically. You will have to manually create tables, indexes and manually alter schema if you make any changed down the road.

Autosync is not only difference. There are few more:

Different:

Mapper Instance

Datastax mapper needs to be instantiated for each entity class. If you have 20 entity classes you will create 20 mappers.

Mapper<Account> mapper = new MappingManager(session).mapper(Account.class);

My mapper is not bound to an entity. You can have just one or 20 – it’s up to you.

MappingSession mapper = new MappingSession("keyspace_name", session);

Composite Primary Key

Datastax PK fields are all declared within entity class:

@Table(keyspace = "ks", name = "test_table")
public static class TestTable {
    @PartitionKey(0)
    private int pk1;

    @PartitionKey(1)
    private int pk2;

    @ClusteringColumn(0)
    private int cc1;

    @ClusteringColumn(1)
    private int cc2;
}