Formatting.

.idea/eclipseCodeFormatter.xml

@@ -3,7 +3,6 @@
   <component name="EclipseCodeFormatterProjectSettings">
     <option name="projectSpecificProfile">
       <ProjectSpecificProfile>
-        <option name="formatter" value="ECLIPSE" />
         <option name="pathToConfigFileJava" value="$PROJECT_DIR$/../newton/formatting/onshape-eclipse-general-preferences.epf" />
       </ProjectSpecificProfile>
     </option>

src/main/java/com/datastax/driver/core/querybuilder/IsNotNullClause.java

@@ -15,9 +15,8 @@
  */
 package com.datastax.driver.core.querybuilder;
 
-import java.util.List;
-
 import com.datastax.driver.core.CodecRegistry;
+import java.util.List;
 
 public class IsNotNullClause extends Clause {
 

src/main/java/com/datastax/driver/core/schemabuilder/CreateCustomIndex.java

@@ -16,8 +16,10 @@ public class CreateCustomIndex extends CreateIndex {
   CreateCustomIndex(String indexName) {
     super(indexName);
     validateNotEmpty(indexName, "Index name");
-		validateNotKeyWord(indexName,
-				String.format("The index name '%s' is not allowed because it is a reserved keyword", indexName));
+    validateNotKeyWord(
+        indexName,
+        String.format(
+            "The index name '%s' is not allowed because it is a reserved keyword", indexName));
     this.indexName = indexName;
   }
 
@@ -34,20 +36,22 @@ public class CreateCustomIndex extends CreateIndex {
   /**
    * Specify the keyspace and table to create the index on.
    *
-	 * @param keyspaceName
-	 *            the keyspace name.
-	 * @param tableName
-	 *            the table name.
-	 * @return a {@link CreateIndex.CreateIndexOn} that will allow the specification
-	 *         of the column.
+   * @param keyspaceName the keyspace name.
+   * @param tableName the table name.
+   * @return a {@link CreateIndex.CreateIndexOn} that will allow the specification of the column.
    */
   public CreateIndex.CreateIndexOn onTable(String keyspaceName, String tableName) {
     validateNotEmpty(keyspaceName, "Keyspace name");
     validateNotEmpty(tableName, "Table name");
-		validateNotKeyWord(keyspaceName,
-				String.format("The keyspace name '%s' is not allowed because it is a reserved keyword", keyspaceName));
-		validateNotKeyWord(tableName,
-				String.format("The table name '%s' is not allowed because it is a reserved keyword", tableName));
+    validateNotKeyWord(
+        keyspaceName,
+        String.format(
+            "The keyspace name '%s' is not allowed because it is a reserved keyword",
+            keyspaceName));
+    validateNotKeyWord(
+        tableName,
+        String.format(
+            "The table name '%s' is not allowed because it is a reserved keyword", tableName));
     this.keyspaceName = Optional.fromNullable(keyspaceName);
     this.tableName = tableName;
     return new CreateCustomIndex.CreateIndexOn();
@@ -56,15 +60,15 @@ public class CreateCustomIndex extends CreateIndex {
   /**
    * Specify the table to create the index on.
    *
-	 * @param tableName
-	 *            the table name.
-	 * @return a {@link CreateIndex.CreateIndexOn} that will allow the specification
-	 *         of the column.
+   * @param tableName the table name.
+   * @return a {@link CreateIndex.CreateIndexOn} that will allow the specification of the column.
    */
   public CreateIndex.CreateIndexOn onTable(String tableName) {
     validateNotEmpty(tableName, "Table name");
-		validateNotKeyWord(tableName,
-				String.format("The table name '%s' is not allowed because it is a reserved keyword", tableName));
+    validateNotKeyWord(
+        tableName,
+        String.format(
+            "The table name '%s' is not allowed because it is a reserved keyword", tableName));
     this.tableName = tableName;
     return new CreateCustomIndex.CreateIndexOn();
   }
@@ -79,7 +83,8 @@ public class CreateCustomIndex extends CreateIndex {
 
   @Override
   public String buildInternal() {
-		StringBuilder createStatement = new StringBuilder(STATEMENT_START).append("CREATE CUSTOM INDEX ");
+    StringBuilder createStatement =
+        new StringBuilder(STATEMENT_START).append("CREATE CUSTOM INDEX ");
 
     if (ifNotExists) {
       createStatement.append("IF NOT EXISTS ");
@@ -117,14 +122,15 @@ public class CreateCustomIndex extends CreateIndex {
     /**
      * Specify the column to create the index on.
      *
-		 * @param columnName
-		 *            the column name.
+     * @param columnName the column name.
      * @return the final CREATE INDEX statement.
      */
     public SchemaStatement andColumn(String columnName) {
       validateNotEmpty(columnName, "Column name");
-			validateNotKeyWord(columnName,
-					String.format("The column name '%s' is not allowed because it is a reserved keyword", columnName));
+      validateNotKeyWord(
+          columnName,
+          String.format(
+              "The column name '%s' is not allowed because it is a reserved keyword", columnName));
       CreateCustomIndex.this.columnName = columnName;
       return SchemaStatement.fromQueryString(buildInternal());
     }
@@ -132,14 +138,15 @@ public class CreateCustomIndex extends CreateIndex {
     /**
      * Create an index on the keys of the given map column.
      *
-		 * @param columnName
-		 *            the column name.
+     * @param columnName the column name.
      * @return the final CREATE INDEX statement.
      */
     public SchemaStatement andKeysOfColumn(String columnName) {
       validateNotEmpty(columnName, "Column name");
-			validateNotKeyWord(columnName,
-					String.format("The column name '%s' is not allowed because it is a reserved keyword", columnName));
+      validateNotKeyWord(
+          columnName,
+          String.format(
+              "The column name '%s' is not allowed because it is a reserved keyword", columnName));
       CreateCustomIndex.this.columnName = columnName;
       CreateCustomIndex.this.keys = true;
       return SchemaStatement.fromQueryString(buildInternal());

src/main/java/com/datastax/driver/core/schemabuilder/CreateMaterializedView.java

@@ -10,7 +10,11 @@ public class CreateMaterializedView extends Create {
   private String primaryKey;
   private String clustering;
 
-	public CreateMaterializedView(String keyspaceName, String viewName, Select.Where selection, String primaryKey,
+  public CreateMaterializedView(
+      String keyspaceName,
+      String viewName,
+      Select.Where selection,
+      String primaryKey,
       String clustering) {
     super(keyspaceName, viewName);
     this.viewName = viewName;
@@ -24,7 +28,8 @@ public class CreateMaterializedView extends Create {
   }
 
   public String buildInternal() {
-		StringBuilder createStatement = new StringBuilder(STATEMENT_START).append("CREATE MATERIALIZED VIEW");
+    StringBuilder createStatement =
+        new StringBuilder(STATEMENT_START).append("CREATE MATERIALIZED VIEW");
     if (ifNotExists) {
       createStatement.append(" IF NOT EXISTS");
     }

src/main/java/com/datastax/driver/core/schemabuilder/CreateSasiIndex.java

@@ -11,7 +11,8 @@ public class CreateSasiIndex extends CreateCustomIndex {
   }
 
   String getOptions() {
-		return "'analyzer_class': " + "'org.apache.cassandra.index.sasi.analyzer.NonTokenizingAnalyzer', "
+    return "'analyzer_class': "
+        + "'org.apache.cassandra.index.sasi.analyzer.NonTokenizingAnalyzer', "
         + "'case_sensitive': 'false'";
   }
 }

src/main/java/com/datastax/driver/core/schemabuilder/DropMaterializedView.java

@@ -7,6 +7,7 @@ public class DropMaterializedView extends Drop {
   private Optional<String> keyspaceName = Optional.absent();
   private String itemName;
   private boolean ifExists = true;
+
   public DropMaterializedView(String keyspaceName, String viewName) {
     this(keyspaceName, viewName, DroppedItem.MATERIALIZED_VIEW);
   }
@@ -43,6 +44,9 @@ public class DropMaterializedView extends Drop {
   }
 
   enum DroppedItem {
-		TABLE, TYPE, INDEX, MATERIALIZED_VIEW
+    TABLE,
+    TYPE,
+    INDEX,
+    MATERIALIZED_VIEW
   }
 }

src/main/java/net/helenus/config/DefaultHelenusSettings.java

@@ -17,7 +17,6 @@ package net.helenus.config;
 
 import java.lang.reflect.Method;
 import java.util.function.Function;
-
 import net.helenus.core.DslInstantiator;
 import net.helenus.core.MapperInstantiator;
 import net.helenus.core.reflect.ReflectionDslInstantiator;

src/main/java/net/helenus/config/GetterMethodDetector.java

@@ -18,7 +18,6 @@ package net.helenus.config;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.util.function.Function;
-
 import net.helenus.mapping.annotation.Transient;
 
 public enum GetterMethodDetector implements Function<Method, Boolean> {

src/main/java/net/helenus/config/HelenusSettings.java

@@ -17,7 +17,6 @@ package net.helenus.config;
 
 import java.lang.reflect.Method;
 import java.util.function.Function;
-
 import net.helenus.core.DslInstantiator;
 import net.helenus.core.MapperInstantiator;
 

src/main/java/net/helenus/core/AbstractAuditedEntityDraft.java

@@ -3,7 +3,6 @@ package net.helenus.core;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.util.Date;
-
 import net.helenus.core.reflect.MapExportable;
 
 public abstract class AbstractAuditedEntityDraft<E> extends AbstractEntityDraft<E> {

src/main/java/net/helenus/core/AbstractEntityDraft.java

@@ -1,16 +1,13 @@
 package net.helenus.core;
 
+import com.google.common.primitives.Primitives;
 import java.io.Serializable;
 import java.util.*;
-
-import org.apache.commons.lang3.SerializationUtils;
-
-import com.google.common.primitives.Primitives;
-
 import net.helenus.core.reflect.DefaultPrimitiveTypes;
 import net.helenus.core.reflect.Drafted;
 import net.helenus.core.reflect.MapExportable;
 import net.helenus.mapping.MappingUtil;
+import org.apache.commons.lang3.SerializationUtils;
 
 public abstract class AbstractEntityDraft<E> implements Drafted<E> {
 

src/main/java/net/helenus/core/AbstractSessionOperations.java

@@ -15,26 +15,23 @@
  */
 package net.helenus.core;
 
-import java.io.PrintStream;
-import java.util.List;
-import java.util.concurrent.Executor;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
+import brave.Tracer;
 import com.codahale.metrics.MetricRegistry;
 import com.datastax.driver.core.*;
 import com.google.common.base.Stopwatch;
 import com.google.common.collect.Table;
 import com.google.common.util.concurrent.ListenableFuture;
-
-import brave.Tracer;
+import java.io.PrintStream;
+import java.util.List;
+import java.util.concurrent.Executor;
 import net.helenus.core.cache.Facet;
 import net.helenus.core.operation.Operation;
 import net.helenus.mapping.value.ColumnValuePreparer;
 import net.helenus.mapping.value.ColumnValueProvider;
 import net.helenus.support.Either;
 import net.helenus.support.HelenusException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public abstract class AbstractSessionOperations {
 
@@ -90,7 +87,8 @@ public abstract class AbstractSessionOperations {
     return execute(statement, uow, null, showValues);
   }
 
-	public ResultSet execute(Statement statement, UnitOfWork uow, Stopwatch timer, boolean showValues) {
+  public ResultSet execute(
+      Statement statement, UnitOfWork uow, Stopwatch timer, boolean showValues) {
     return executeAsync(statement, uow, timer, showValues).getUninterruptibly();
   }
 
@@ -106,7 +104,8 @@ public abstract class AbstractSessionOperations {
     return executeAsync(statement, uow, null, showValues);
   }
 
-	public ResultSetFuture executeAsync(Statement statement, UnitOfWork uow, Stopwatch timer, boolean showValues) {
+  public ResultSetFuture executeAsync(
+      Statement statement, UnitOfWork uow, Stopwatch timer, boolean showValues) {
     try {
       logStatement(statement, showValues);
       return currentSession().executeAsync(statement);
@@ -131,8 +130,7 @@ public abstract class AbstractSessionOperations {
     return null;
   }
 
-	public void mergeCache(Table<String, String, Either<Object, List<Facet>>> uowCache) {
-	}
+  public void mergeCache(Table<String, String, Either<Object, List<Facet>>> uowCache) {}
 
   RuntimeException translateException(RuntimeException e) {
     if (e instanceof HelenusException) {
@@ -145,13 +143,11 @@ public abstract class AbstractSessionOperations {
     return null;
   }
 
-	public void updateCache(Object pojo, List<Facet> facets) {
-	}
+  public void updateCache(Object pojo, List<Facet> facets) {}
 
   void printCql(String cql) {
     getPrintStream().println(cql);
   }
 
-	public void cacheEvict(List<Facet> facets) {
-	}
+  public void cacheEvict(List<Facet> facets) {}
 }

src/main/java/net/helenus/core/AbstractUnitOfWork.java

@@ -17,25 +17,23 @@ package net.helenus.core;
 
 import static net.helenus.core.HelenusSession.deleted;
 
-import java.util.*;
-import java.util.concurrent.TimeUnit;
-import java.util.stream.Collectors;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.diffplug.common.base.Errors;
 import com.google.common.base.Stopwatch;
 import com.google.common.collect.HashBasedTable;
 import com.google.common.collect.Table;
 import com.google.common.collect.TreeTraverser;
-
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.stream.Collectors;
 import net.helenus.core.cache.CacheUtil;
 import net.helenus.core.cache.Facet;
 import net.helenus.support.Either;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /** Encapsulates the concept of a "transaction" as a unit-of-work. */
-public abstract class AbstractUnitOfWork<E extends Exception> implements UnitOfWork<E>, AutoCloseable {
+public abstract class AbstractUnitOfWork<E extends Exception>
+    implements UnitOfWork<E>, AutoCloseable {
 
   private static final Logger LOG = LoggerFactory.getLogger(AbstractUnitOfWork.class);
 
@@ -136,26 +134,46 @@ public abstract class AbstractUnitOfWork<E extends Exception> implements UnitOfW
         dbt.add(String.format("%s took %,.3fms %,2.2f%%", dt.getKey(), t, (t / e) * 100.0));
       }
       double fd = (d / e) * 100.0;
-			database = String.format(", %d quer%s (%,.3fms %,2.2f%% - %s)", databaseLookups,
-					(databaseLookups > 1) ? "ies" : "y", d, fd, String.join(", ", dbt));
+      database =
+          String.format(
+              ", %d quer%s (%,.3fms %,2.2f%% - %s)",
+              databaseLookups, (databaseLookups > 1) ? "ies" : "y", d, fd, String.join(", ", dbt));
     }
     String cache = "";
     if (cacheLookupTime > 0) {
       int cacheLookups = cacheHits + cacheMisses;
-			cache = String.format(" with %d cache lookup%s (%,.3fms %,2.2f%% - %,d hit, %,d miss)", cacheLookups,
-					cacheLookups > 1 ? "s" : "", c, fc, cacheHits, cacheMisses);
+      cache =
+          String.format(
+              " with %d cache lookup%s (%,.3fms %,2.2f%% - %,d hit, %,d miss)",
+              cacheLookups, cacheLookups > 1 ? "s" : "", c, fc, cacheHits, cacheMisses);
     }
     String da = "";
     if (databaseTime.size() > 0 || cacheLookupTime > 0) {
       double dat = d + c;
       double daf = (dat / e) * 100;
-			da = String.format(" consuming %,.3fms for data access, or %,2.2f%% of total UOW time.", dat, daf);
+      da =
+          String.format(
+              " consuming %,.3fms for data access, or %,2.2f%% of total UOW time.", dat, daf);
     }
     String x = nestedPurposes.stream().distinct().collect(Collectors.joining(", "));
-		String n = nested.stream().map(uow -> String.valueOf(uow.hashCode())).collect(Collectors.joining(", "));
-		String s = String.format(Locale.US, "UOW(%s%s) %s in %,.3fms%s%s%s%s%s%s", hashCode(),
-				(nested.size() > 0 ? ", [" + n + "]" : ""), what, e, cache, database, da,
-				(purpose == null ? "" : " " + purpose), (nestedPurposes.isEmpty()) ? "" : ", " + x,
+    String n =
+        nested
+            .stream()
+            .map(uow -> String.valueOf(uow.hashCode()))
+            .collect(Collectors.joining(", "));
+    String s =
+        String.format(
+            Locale.US,
+            "UOW(%s%s) %s in %,.3fms%s%s%s%s%s%s",
+            hashCode(),
+            (nested.size() > 0 ? ", [" + n + "]" : ""),
+            what,
+            e,
+            cache,
+            database,
+            da,
+            (purpose == null ? "" : " " + purpose),
+            (nestedPurposes.isEmpty()) ? "" : ", " + x,
             (info == null) ? "" : " " + info);
     return s;
   }
@@ -215,7 +233,10 @@ public abstract class AbstractUnitOfWork<E extends Exception> implements UnitOfW
       }
       // look for other row/col pairs that referenced the same object, mark them
       // `deleted`
-			cache.columnKeySet().forEach(columnKey -> {
+      cache
+          .columnKeySet()
+          .forEach(
+              columnKey -> {
                 Either<Object, List<Facet>> eitherCachedValue = cache.get(tableName, columnKey);
                 if (eitherCachedValue.isLeft()) {
                   Object cachedValue = eitherCachedValue.getLeft();
@@ -246,19 +267,17 @@ public abstract class AbstractUnitOfWork<E extends Exception> implements UnitOfW
   }
 
   /**
-	 * Checks to see if the work performed between calling begin and now can be
-	 * committed or not.
+   * Checks to see if the work performed between calling begin and now can be committed or not.
    *
-	 * @return a function from which to chain work that only happens when commit is
-	 *         successful
-	 * @throws E
-	 *             when the work overlaps with other concurrent writers.
+   * @return a function from which to chain work that only happens when commit is successful
+   * @throws E when the work overlaps with other concurrent writers.
    */
   public PostCommitFunction<Void, Void> commit() throws E {
     // All nested UnitOfWork should be committed (not aborted) before calls to
     // commit, check.
     boolean canCommit = true;
-		TreeTraverser<AbstractUnitOfWork<E>> traverser = TreeTraverser.using(node -> node::getChildNodes);
+    TreeTraverser<AbstractUnitOfWork<E>> traverser =
+        TreeTraverser.using(node -> node::getChildNodes);
     for (AbstractUnitOfWork<E> uow : traverser.postOrderTraversal(this)) {
       if (this != uow) {
         canCommit &= (!uow.aborted && uow.committed);
@@ -281,7 +300,10 @@ public abstract class AbstractUnitOfWork<E extends Exception> implements UnitOfW
 
       if (parent == null) {
         // Apply all post-commit functions, this is the outter-most UnitOfWork.
-				traverser.postOrderTraversal(this).forEach(uow -> {
+        traverser
+            .postOrderTraversal(this)
+            .forEach(
+                uow -> {
                   uow.applyPostCommitFunctions();
                 });
 
@@ -320,8 +342,12 @@ public abstract class AbstractUnitOfWork<E extends Exception> implements UnitOfW
 
   /* Explicitly discard the work and mark it as as such in the log. */
   public synchronized void abort() {
-		TreeTraverser<AbstractUnitOfWork<E>> traverser = TreeTraverser.using(node -> node::getChildNodes);
-		traverser.postOrderTraversal(this).forEach(uow -> {
+    TreeTraverser<AbstractUnitOfWork<E>> traverser =
+        TreeTraverser.using(node -> node::getChildNodes);
+    traverser
+        .postOrderTraversal(this)
+        .forEach(
+            uow -> {
               uow.committed = false;
               uow.aborted = true;
             });
@@ -337,11 +363,19 @@ public abstract class AbstractUnitOfWork<E extends Exception> implements UnitOfW
 
   private void mergeCache(Table<String, String, Either<Object, List<Facet>>> from) {
     Table<String, String, Either<Object, List<Facet>>> to = this.cache;
-		from.rowMap().forEach((rowKey, columnMap) -> {
-			columnMap.forEach((columnKey, value) -> {
+    from.rowMap()
+        .forEach(
+            (rowKey, columnMap) -> {
+              columnMap.forEach(
+                  (columnKey, value) -> {
                     if (to.contains(rowKey, columnKey)) {
                       // TODO(gburd):...
-					to.put(rowKey, columnKey, Either.left(CacheUtil.merge(to.get(rowKey, columnKey).getLeft(),
+                      to.put(
+                          rowKey,
+                          columnKey,
+                          Either.left(
+                              CacheUtil.merge(
+                                  to.get(rowKey, columnKey).getLeft(),
                                   from.get(rowKey, columnKey).getLeft())));
                     } else {
                       to.put(rowKey, columnKey, from.get(rowKey, columnKey));

src/main/java/net/helenus/core/AutoDdl.java

@@ -16,5 +16,8 @@
 package net.helenus.core;
 
 public enum AutoDdl {
-	VALIDATE, UPDATE, CREATE, CREATE_DROP;
+  VALIDATE,
+  UPDATE,
+  CREATE,
+  CREATE_DROP;
 }

src/main/java/net/helenus/core/DslInstantiator.java

@@ -15,13 +15,15 @@
  */
 package net.helenus.core;
 
-import java.util.Optional;
-
 import com.datastax.driver.core.Metadata;
-
+import java.util.Optional;
 import net.helenus.core.reflect.HelenusPropertyNode;
 
 public interface DslInstantiator {
 
-	<E> E instantiate(Class<E> iface, ClassLoader classLoader, Optional<HelenusPropertyNode> parent, Metadata metadata);
+  <E> E instantiate(
+      Class<E> iface,
+      ClassLoader classLoader,
+      Optional<HelenusPropertyNode> parent,
+      Metadata metadata);
 }

src/main/java/net/helenus/core/Filter.java

@@ -15,10 +15,8 @@
  */
 package net.helenus.core;
 
-import java.util.Objects;
-
 import com.datastax.driver.core.querybuilder.Clause;
-
+import java.util.Objects;
 import net.helenus.core.reflect.HelenusPropertyNode;
 import net.helenus.mapping.MappingUtil;
 import net.helenus.mapping.value.ColumnValuePreparer;
@@ -87,7 +85,8 @@ public final class Filter<V> {
     Objects.requireNonNull(val, "empty value");
 
     if (op == Operator.IN) {
-			throw new IllegalArgumentException("invalid usage of the 'in' operator, use Filter.in() static method");
+      throw new IllegalArgumentException(
+          "invalid usage of the 'in' operator, use Filter.in() static method");
     }
 
     HelenusPropertyNode node = MappingUtil.resolveMappingProperty(getter);

src/main/java/net/helenus/core/Helenus.java

@@ -15,17 +15,15 @@
  */
 package net.helenus.core;
 
+import com.datastax.driver.core.Cluster;
+import com.datastax.driver.core.Metadata;
+import com.datastax.driver.core.Session;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
-
-import com.datastax.driver.core.Cluster;
-import com.datastax.driver.core.Metadata;
-import com.datastax.driver.core.Session;
-
 import net.helenus.config.DefaultHelenusSettings;
 import net.helenus.config.HelenusSettings;
 import net.helenus.core.reflect.DslExportable;
@@ -35,14 +33,15 @@ import net.helenus.support.HelenusMappingException;
 
 public final class Helenus {
 
-	private static final ConcurrentMap<Class<?>, Object> dslCache = new ConcurrentHashMap<Class<?>, Object>();
-	private static final ConcurrentMap<Class<?>, Metadata> metadataForEntity = new ConcurrentHashMap<Class<?>, Metadata>();
+  private static final ConcurrentMap<Class<?>, Object> dslCache =
+      new ConcurrentHashMap<Class<?>, Object>();
+  private static final ConcurrentMap<Class<?>, Metadata> metadataForEntity =
+      new ConcurrentHashMap<Class<?>, Metadata>();
   private static final Set<HelenusSession> sessions = new HashSet<HelenusSession>();
   private static volatile HelenusSettings settings = new DefaultHelenusSettings();
   private static volatile HelenusSession singleton;
 
-	private Helenus() {
-	}
+  private Helenus() {}
 
   protected static void setSession(HelenusSession session) {
     sessions.add(session);
@@ -54,7 +53,8 @@ public final class Helenus {
   }
 
   public static void shutdown() {
-		sessions.forEach((session) -> {
+    sessions.forEach(
+        (session) -> {
           session.close();
           sessions.remove(session);
         });
@@ -106,7 +106,10 @@ public final class Helenus {
     return dsl(iface, classLoader, Optional.empty(), metadata);
   }
 
-	public static <E> E dsl(Class<E> iface, ClassLoader classLoader, Optional<HelenusPropertyNode> parent,
+  public static <E> E dsl(
+      Class<E> iface,
+      ClassLoader classLoader,
+      Optional<HelenusPropertyNode> parent,
       Metadata metadata) {
 
     Object instance = null;

src/main/java/net/helenus/core/HelenusSession.java

@@ -17,6 +17,10 @@ package net.helenus.core;
 
 import static net.helenus.core.Query.eq;
 
+import brave.Tracer;
+import com.codahale.metrics.MetricRegistry;
+import com.datastax.driver.core.*;
+import com.google.common.collect.Table;
 import java.io.Closeable;
 import java.io.PrintStream;
 import java.lang.reflect.Constructor;
@@ -27,15 +31,6 @@ import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import com.codahale.metrics.MetricRegistry;
-import com.datastax.driver.core.*;
-import com.google.common.collect.Table;
-
-import brave.Tracer;
 import net.helenus.core.cache.CacheUtil;
 import net.helenus.core.cache.Facet;
 import net.helenus.core.cache.SessionCache;
@@ -52,12 +47,15 @@ import net.helenus.support.*;
 import net.helenus.support.Fun.Tuple1;
 import net.helenus.support.Fun.Tuple2;
 import net.helenus.support.Fun.Tuple6;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class HelenusSession extends AbstractSessionOperations implements Closeable {
 
   public static final Object deleted = new Object();
   private static final Logger LOG = LoggerFactory.getLogger(HelenusSession.class);
-	private static final Pattern classNameRegex = Pattern.compile("^(?:\\w+\\.)+(?:(\\w+)|(\\w+)\\$.*)$");
+  private static final Pattern classNameRegex =
+      Pattern.compile("^(?:\\w+\\.)+(?:(\\w+)|(\\w+)\\$.*)$");
 
   private final Session session;
   private final CodecRegistry registry;
@@ -77,15 +75,26 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
   private volatile String usingKeyspace;
   private volatile boolean showCql;
 
-	HelenusSession(Session session, String usingKeyspace, CodecRegistry registry, boolean showCql,
-			PrintStream printStream, SessionRepositoryBuilder sessionRepositoryBuilder, Executor executor,
-			boolean dropSchemaOnClose, ConsistencyLevel consistencyLevel, boolean defaultQueryIdempotency,
-			Class<? extends UnitOfWork> unitOfWorkClass, SessionCache sessionCache, MetricRegistry metricRegistry,
+  HelenusSession(
+      Session session,
+      String usingKeyspace,
+      CodecRegistry registry,
+      boolean showCql,
+      PrintStream printStream,
+      SessionRepositoryBuilder sessionRepositoryBuilder,
+      Executor executor,
+      boolean dropSchemaOnClose,
+      ConsistencyLevel consistencyLevel,
+      boolean defaultQueryIdempotency,
+      Class<? extends UnitOfWork> unitOfWorkClass,
+      SessionCache sessionCache,
+      MetricRegistry metricRegistry,
       Tracer tracer) {
     this.session = session;
     this.registry = registry == null ? CodecRegistry.DEFAULT_INSTANCE : registry;
-		this.usingKeyspace = Objects.requireNonNull(usingKeyspace,
-				"keyspace needs to be selected before creating session");
+    this.usingKeyspace =
+        Objects.requireNonNull(
+            usingKeyspace, "keyspace needs to be selected before creating session");
     this.showCql = showCql;
     this.printStream = printStream;
     this.sessionRepository = sessionRepositoryBuilder.build();
@@ -210,7 +219,8 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
 
   @Override
   public void updateCache(Object pojo, List<Facet> facets) {
-		Map<String, Object> valueMap = pojo instanceof MapExportable ? ((MapExportable) pojo).toMap() : null;
+    Map<String, Object> valueMap =
+        pojo instanceof MapExportable ? ((MapExportable) pojo).toMap() : null;
     List<Facet> boundFacets = new ArrayList<>();
     for (Facet facet : facets) {
       if (facet instanceof UnboundFacet) {
@@ -242,23 +252,35 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
 
   @Override
   public void mergeCache(Table<String, String, Either<Object, List<Facet>>> uowCache) {
-		List<Object> items = uowCache.values().stream().filter(Either::isLeft).map(Either::getLeft).distinct()
+    List<Object> items =
+        uowCache
+            .values()
+            .stream()
+            .filter(Either::isLeft)
+            .map(Either::getLeft)
+            .distinct()
             .collect(Collectors.toList());
     for (Object pojo : items) {
       HelenusEntity entity = Helenus.resolve(MappingUtil.getMappingInterface(pojo));
-			Map<String, Object> valueMap = pojo instanceof MapExportable ? ((MapExportable) pojo).toMap() : null;
+      Map<String, Object> valueMap =
+          pojo instanceof MapExportable ? ((MapExportable) pojo).toMap() : null;
       if (entity.isCacheable()) {
         List<Facet> boundFacets = new ArrayList<>();
         for (Facet facet : entity.getFacets()) {
           if (facet instanceof UnboundFacet) {
             UnboundFacet unboundFacet = (UnboundFacet) facet;
             UnboundFacet.Binder binder = unboundFacet.binder();
-						unboundFacet.getProperties().forEach(prop -> {
+            unboundFacet
+                .getProperties()
+                .forEach(
+                    prop -> {
                       if (valueMap == null) {
-								Object value = BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop);
+                        Object value =
+                            BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop);
                         binder.setValueForProperty(prop, value.toString());
                       } else {
-								binder.setValueForProperty(prop, valueMap.get(prop.getPropertyName()).toString());
+                        binder.setValueForProperty(
+                            prop, valueMap.get(prop.getPropertyName()).toString());
                       }
                     });
             if (binder.isBound()) {
@@ -274,7 +296,12 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
       }
     }
 
-		List<List<Facet>> deletedFacetSets = uowCache.values().stream().filter(Either::isRight).map(Either::getRight)
+    List<List<Facet>> deletedFacetSets =
+        uowCache
+            .values()
+            .stream()
+            .filter(Either::isRight)
+            .map(Either::getRight)
             .collect(Collectors.toList());
     for (List<Facet> facets : deletedFacetSets) {
       String tableName = CacheUtil.schemaName(facets);
@@ -286,7 +313,8 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
     }
   }
 
-	private void replaceCachedFacetValues(Object pojo, String tableName, List<String[]> facetCombinations) {
+  private void replaceCachedFacetValues(
+      Object pojo, String tableName, List<String[]> facetCombinations) {
     for (String[] combination : facetCombinations) {
       String cacheKey = tableName + "." + Arrays.toString(combination);
       sessionCache.invalidate(cacheKey);
@@ -316,7 +344,8 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
   public synchronized UnitOfWork begin(UnitOfWork parent) {
     try {
       Class<? extends UnitOfWork> clazz = unitOfWorkClass;
-			Constructor<? extends UnitOfWork> ctor = clazz.getConstructor(HelenusSession.class, UnitOfWork.class);
+      Constructor<? extends UnitOfWork> ctor =
+          clazz.getConstructor(HelenusSession.class, UnitOfWork.class);
       UnitOfWork uow = ctor.newInstance(this, parent);
       if (LOG.isInfoEnabled() && uow.getPurpose() == null) {
         StringBuilder purpose = null;
@@ -333,9 +362,16 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
           stackClassName = extractClassNameFromStackFrame(trace[frame].getClassName());
         } while (stackClassName.equals(targetClassName) && frame < trace.length);
         if (frame < trace.length) {
-					purpose = new StringBuilder().append(trace[frame].getClassName()).append(".")
-							.append(trace[frame].getMethodName()).append("(").append(trace[frame].getFileName())
-							.append(":").append(trace[frame].getLineNumber()).append(")");
+          purpose =
+              new StringBuilder()
+                  .append(trace[frame].getClassName())
+                  .append(".")
+                  .append(trace[frame].getMethodName())
+                  .append("(")
+                  .append(trace[frame].getFileName())
+                  .append(":")
+                  .append(trace[frame].getLineNumber())
+                  .append(")");
           uow.setPurpose(purpose.toString());
         }
       }
@@ -343,20 +379,28 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
         parent.addNestedUnitOfWork(uow);
       }
       return uow.begin();
-		} catch (NoSuchMethodException | InvocationTargetException | InstantiationException
+    } catch (NoSuchMethodException
+        | InvocationTargetException
+        | InstantiationException
         | IllegalAccessException e) {
       throw new HelenusException(
-					String.format("Unable to instantiate %s as a UnitOfWork.", unitOfWorkClass.getSimpleName()), e);
+          String.format(
+              "Unable to instantiate %s as a UnitOfWork.", unitOfWorkClass.getSimpleName()),
+          e);
     }
   }
 
   public <E> SelectOperation<E> select(E pojo) {
-		Objects.requireNonNull(pojo, "supplied object must be a dsl for a registered entity but cannot be null");
+    Objects.requireNonNull(
+        pojo, "supplied object must be a dsl for a registered entity but cannot be null");
     ColumnValueProvider valueProvider = getValueProvider();
     HelenusEntity entity = Helenus.resolve(pojo);
     Class<?> entityClass = entity.getMappingInterface();
 
-		return new SelectOperation<E>(this, entity, (r) -> {
+    return new SelectOperation<E>(
+        this,
+        entity,
+        (r) -> {
           Map<String, Object> map = new ValueProviderMap(r, valueProvider, entity);
           return (E) Helenus.map(entityClass, map);
         });
@@ -367,7 +411,10 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
     ColumnValueProvider valueProvider = getValueProvider();
     HelenusEntity entity = Helenus.entity(entityClass);
 
-		return new SelectOperation<E>(this, entity, (r) -> {
+    return new SelectOperation<E>(
+        this,
+        entity,
+        (r) -> {
           Map<String, Object> map = new ValueProviderMap(r, valueProvider, entity);
           return (E) Helenus.map(entityClass, map);
         });
@@ -383,7 +430,8 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
   }
 
   public <E> SelectOperation<Row> selectAll(E pojo) {
-		Objects.requireNonNull(pojo, "supplied object must be a dsl for a registered entity but cannot be null");
+    Objects.requireNonNull(
+        pojo, "supplied object must be a dsl for a registered entity but cannot be null");
     HelenusEntity entity = Helenus.resolve(pojo);
     return new SelectOperation<Row>(this, entity);
   }
@@ -398,7 +446,8 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
     Objects.requireNonNull(getter1, "field 1 is empty");
 
     HelenusPropertyNode p1 = MappingUtil.resolveMappingProperty(getter1);
-		return new SelectOperation<Tuple1<V1>>(this, new Mappers.Mapper1<V1>(getValueProvider(), p1), p1);
+    return new SelectOperation<Tuple1<V1>>(
+        this, new Mappers.Mapper1<V1>(getValueProvider(), p1), p1);
   }
 
   public <V1, V2> SelectOperation<Tuple2<V1, V2>> select(Getter<V1> getter1, Getter<V2> getter2) {
@@ -407,12 +456,12 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
 
     HelenusPropertyNode p1 = MappingUtil.resolveMappingProperty(getter1);
     HelenusPropertyNode p2 = MappingUtil.resolveMappingProperty(getter2);
-		return new SelectOperation<Fun.Tuple2<V1, V2>>(this, new Mappers.Mapper2<V1, V2>(getValueProvider(), p1, p2),
-				p1, p2);
+    return new SelectOperation<Fun.Tuple2<V1, V2>>(
+        this, new Mappers.Mapper2<V1, V2>(getValueProvider(), p1, p2), p1, p2);
   }
 
-	public <V1, V2, V3> SelectOperation<Fun.Tuple3<V1, V2, V3>> select(Getter<V1> getter1, Getter<V2> getter2,
-			Getter<V3> getter3) {
+  public <V1, V2, V3> SelectOperation<Fun.Tuple3<V1, V2, V3>> select(
+      Getter<V1> getter1, Getter<V2> getter2, Getter<V3> getter3) {
     Objects.requireNonNull(getter1, "field 1 is empty");
     Objects.requireNonNull(getter2, "field 2 is empty");
     Objects.requireNonNull(getter3, "field 3 is empty");
@@ -420,12 +469,12 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
     HelenusPropertyNode p1 = MappingUtil.resolveMappingProperty(getter1);
     HelenusPropertyNode p2 = MappingUtil.resolveMappingProperty(getter2);
     HelenusPropertyNode p3 = MappingUtil.resolveMappingProperty(getter3);
-		return new SelectOperation<Fun.Tuple3<V1, V2, V3>>(this,
-				new Mappers.Mapper3<V1, V2, V3>(getValueProvider(), p1, p2, p3), p1, p2, p3);
+    return new SelectOperation<Fun.Tuple3<V1, V2, V3>>(
+        this, new Mappers.Mapper3<V1, V2, V3>(getValueProvider(), p1, p2, p3), p1, p2, p3);
   }
 
-	public <V1, V2, V3, V4> SelectOperation<Fun.Tuple4<V1, V2, V3, V4>> select(Getter<V1> getter1, Getter<V2> getter2,
-			Getter<V3> getter3, Getter<V4> getter4) {
+  public <V1, V2, V3, V4> SelectOperation<Fun.Tuple4<V1, V2, V3, V4>> select(
+      Getter<V1> getter1, Getter<V2> getter2, Getter<V3> getter3, Getter<V4> getter4) {
     Objects.requireNonNull(getter1, "field 1 is empty");
     Objects.requireNonNull(getter2, "field 2 is empty");
     Objects.requireNonNull(getter3, "field 3 is empty");
@@ -435,12 +484,21 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
     HelenusPropertyNode p2 = MappingUtil.resolveMappingProperty(getter2);
     HelenusPropertyNode p3 = MappingUtil.resolveMappingProperty(getter3);
     HelenusPropertyNode p4 = MappingUtil.resolveMappingProperty(getter4);
-		return new SelectOperation<Fun.Tuple4<V1, V2, V3, V4>>(this,
-				new Mappers.Mapper4<V1, V2, V3, V4>(getValueProvider(), p1, p2, p3, p4), p1, p2, p3, p4);
+    return new SelectOperation<Fun.Tuple4<V1, V2, V3, V4>>(
+        this,
+        new Mappers.Mapper4<V1, V2, V3, V4>(getValueProvider(), p1, p2, p3, p4),
+        p1,
+        p2,
+        p3,
+        p4);
   }
 
-	public <V1, V2, V3, V4, V5> SelectOperation<Fun.Tuple5<V1, V2, V3, V4, V5>> select(Getter<V1> getter1,
-			Getter<V2> getter2, Getter<V3> getter3, Getter<V4> getter4, Getter<V5> getter5) {
+  public <V1, V2, V3, V4, V5> SelectOperation<Fun.Tuple5<V1, V2, V3, V4, V5>> select(
+      Getter<V1> getter1,
+      Getter<V2> getter2,
+      Getter<V3> getter3,
+      Getter<V4> getter4,
+      Getter<V5> getter5) {
     Objects.requireNonNull(getter1, "field 1 is empty");
     Objects.requireNonNull(getter2, "field 2 is empty");
     Objects.requireNonNull(getter3, "field 3 is empty");
@@ -452,12 +510,23 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
     HelenusPropertyNode p3 = MappingUtil.resolveMappingProperty(getter3);
     HelenusPropertyNode p4 = MappingUtil.resolveMappingProperty(getter4);
     HelenusPropertyNode p5 = MappingUtil.resolveMappingProperty(getter5);
-		return new SelectOperation<Fun.Tuple5<V1, V2, V3, V4, V5>>(this,
-				new Mappers.Mapper5<V1, V2, V3, V4, V5>(getValueProvider(), p1, p2, p3, p4, p5), p1, p2, p3, p4, p5);
+    return new SelectOperation<Fun.Tuple5<V1, V2, V3, V4, V5>>(
+        this,
+        new Mappers.Mapper5<V1, V2, V3, V4, V5>(getValueProvider(), p1, p2, p3, p4, p5),
+        p1,
+        p2,
+        p3,
+        p4,
+        p5);
   }
 
-	public <V1, V2, V3, V4, V5, V6> SelectOperation<Fun.Tuple6<V1, V2, V3, V4, V5, V6>> select(Getter<V1> getter1,
-			Getter<V2> getter2, Getter<V3> getter3, Getter<V4> getter4, Getter<V5> getter5, Getter<V6> getter6) {
+  public <V1, V2, V3, V4, V5, V6> SelectOperation<Fun.Tuple6<V1, V2, V3, V4, V5, V6>> select(
+      Getter<V1> getter1,
+      Getter<V2> getter2,
+      Getter<V3> getter3,
+      Getter<V4> getter4,
+      Getter<V5> getter5,
+      Getter<V6> getter6) {
     Objects.requireNonNull(getter1, "field 1 is empty");
     Objects.requireNonNull(getter2, "field 2 is empty");
     Objects.requireNonNull(getter3, "field 3 is empty");
@@ -471,14 +540,26 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
     HelenusPropertyNode p4 = MappingUtil.resolveMappingProperty(getter4);
     HelenusPropertyNode p5 = MappingUtil.resolveMappingProperty(getter5);
     HelenusPropertyNode p6 = MappingUtil.resolveMappingProperty(getter6);
-		return new SelectOperation<Tuple6<V1, V2, V3, V4, V5, V6>>(this,
-				new Mappers.Mapper6<V1, V2, V3, V4, V5, V6>(getValueProvider(), p1, p2, p3, p4, p5, p6), p1, p2, p3, p4,
-				p5, p6);
+    return new SelectOperation<Tuple6<V1, V2, V3, V4, V5, V6>>(
+        this,
+        new Mappers.Mapper6<V1, V2, V3, V4, V5, V6>(getValueProvider(), p1, p2, p3, p4, p5, p6),
+        p1,
+        p2,
+        p3,
+        p4,
+        p5,
+        p6);
   }
 
-	public <V1, V2, V3, V4, V5, V6, V7> SelectOperation<Fun.Tuple7<V1, V2, V3, V4, V5, V6, V7>> select(
-			Getter<V1> getter1, Getter<V2> getter2, Getter<V3> getter3, Getter<V4> getter4, Getter<V5> getter5,
-			Getter<V6> getter6, Getter<V7> getter7) {
+  public <V1, V2, V3, V4, V5, V6, V7>
+      SelectOperation<Fun.Tuple7<V1, V2, V3, V4, V5, V6, V7>> select(
+          Getter<V1> getter1,
+          Getter<V2> getter2,
+          Getter<V3> getter3,
+          Getter<V4> getter4,
+          Getter<V5> getter5,
+          Getter<V6> getter6,
+          Getter<V7> getter7) {
     Objects.requireNonNull(getter1, "field 1 is empty");
     Objects.requireNonNull(getter2, "field 2 is empty");
     Objects.requireNonNull(getter3, "field 3 is empty");
@@ -494,9 +575,17 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
     HelenusPropertyNode p5 = MappingUtil.resolveMappingProperty(getter5);
     HelenusPropertyNode p6 = MappingUtil.resolveMappingProperty(getter6);
     HelenusPropertyNode p7 = MappingUtil.resolveMappingProperty(getter7);
-		return new SelectOperation<Fun.Tuple7<V1, V2, V3, V4, V5, V6, V7>>(this,
-				new Mappers.Mapper7<V1, V2, V3, V4, V5, V6, V7>(getValueProvider(), p1, p2, p3, p4, p5, p6, p7), p1, p2,
-				p3, p4, p5, p6, p7);
+    return new SelectOperation<Fun.Tuple7<V1, V2, V3, V4, V5, V6, V7>>(
+        this,
+        new Mappers.Mapper7<V1, V2, V3, V4, V5, V6, V7>(
+            getValueProvider(), p1, p2, p3, p4, p5, p6, p7),
+        p1,
+        p2,
+        p3,
+        p4,
+        p5,
+        p6,
+        p7);
   }
 
   public CountOperation count() {
@@ -532,19 +621,24 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
     HelenusEntity entity = Helenus.entity(draft.getEntityClass());
 
     // Add all the mutated values contained in the draft.
-		entity.getOrderedProperties().forEach(property -> {
+    entity
+        .getOrderedProperties()
+        .forEach(
+            property -> {
               switch (property.getColumnType()) {
-				case PARTITION_KEY :
-				case CLUSTERING_COLUMN :
+                case PARTITION_KEY:
+                case CLUSTERING_COLUMN:
                   break;
-				default :
+                default:
                   String propertyName = property.getPropertyName();
                   if (mutatedProperties.contains(propertyName)) {
                     Object value = map.get(propertyName);
-						Getter<Object> getter = new Getter<Object>() {
+                    Getter<Object> getter =
+                        new Getter<Object>() {
                           @Override
                           public Object get() {
-								throw new DslPropertyException(new HelenusPropertyNode(property, Optional.empty()));
+                            throw new DslPropertyException(
+                                new HelenusPropertyNode(property, Optional.empty()));
                           }
                         };
                     update.set(getter, value);
@@ -554,16 +648,21 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
 
     // Add the partition and clustering keys if they were in the draft (normally the
     // case).
-		entity.getOrderedProperties().forEach(property -> {
+    entity
+        .getOrderedProperties()
+        .forEach(
+            property -> {
               switch (property.getColumnType()) {
-				case PARTITION_KEY :
-				case CLUSTERING_COLUMN :
+                case PARTITION_KEY:
+                case CLUSTERING_COLUMN:
                   String propertyName = property.getPropertyName();
                   Object value = map.get(propertyName);
-					Getter<Object> getter = new Getter<Object>() {
+                  Getter<Object> getter =
+                      new Getter<Object>() {
                         @Override
                         public Object get() {
-							throw new DslPropertyException(new HelenusPropertyNode(property, Optional.empty()));
+                          throw new DslPropertyException(
+                              new HelenusPropertyNode(property, Optional.empty()));
                         }
                       };
                   update.where(getter, eq(value));
@@ -591,7 +690,8 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
   }
 
   public <T> InsertOperation<T> insert(T pojo) {
-		Objects.requireNonNull(pojo,
+    Objects.requireNonNull(
+        pojo,
         "supplied object must be either an instance of the entity class or a dsl for it, but cannot be null");
     HelenusEntity entity = null;
     try {
@@ -631,7 +731,8 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
   }
 
   public <T> InsertOperation<T> upsert(T pojo) {
-		Objects.requireNonNull(pojo,
+    Objects.requireNonNull(
+        pojo,
         "supplied object must be either an instance of the entity class or a dsl for it, but cannot be null");
     HelenusEntity entity = null;
     try {
@@ -701,15 +802,15 @@ public class HelenusSession extends AbstractSessionOperations implements Closeab
   private void dropEntity(HelenusEntity entity) {
 
     switch (entity.getType()) {
-			case TABLE :
+      case TABLE:
         execute(SchemaUtil.dropTable(entity), true);
         break;
 
-			case UDT :
+      case UDT:
         execute(SchemaUtil.dropUserType(entity), true);
         break;
 
-			default :
+      default:
         throw new HelenusException("Unknown entity type.");
     }
   }

src/main/java/net/helenus/core/HelenusValidator.java

@@ -16,9 +16,7 @@
 package net.helenus.core;
 
 import java.lang.annotation.Annotation;
-
 import javax.validation.ConstraintValidator;
-
 import net.helenus.mapping.HelenusProperty;
 import net.helenus.support.HelenusException;
 import net.helenus.support.HelenusMappingException;
@@ -37,7 +35,8 @@ public enum HelenusValidator implements PropertyValueValidator {
       try {
         valid = typeless.isValid(value, null);
       } catch (ClassCastException e) {
-				throw new HelenusMappingException("validator was used for wrong type '" + value + "' in " + prop, e);
+        throw new HelenusMappingException(
+            "validator was used for wrong type '" + value + "' in " + prop, e);
       }
 
       if (!valid) {

src/main/java/net/helenus/core/Mappers.java

@@ -15,10 +15,8 @@
  */
 package net.helenus.core;
 
-import java.util.function.Function;
-
 import com.datastax.driver.core.Row;
-
+import java.util.function.Function;
 import net.helenus.core.reflect.HelenusPropertyNode;
 import net.helenus.mapping.HelenusProperty;
 import net.helenus.mapping.value.ColumnValueProvider;
@@ -26,8 +24,7 @@ import net.helenus.support.Fun;
 
 public final class Mappers {
 
-	private Mappers() {
-	}
+  private Mappers() {}
 
   public static final class Mapper1<A> implements Function<Row, Fun.Tuple1<A>> {
 
@@ -59,7 +56,8 @@ public final class Mappers {
 
     @Override
     public Fun.Tuple2<A, B> apply(Row row) {
-			return new Fun.Tuple2<A, B>(provider.getColumnValue(row, 0, p1), provider.getColumnValue(row, 1, p2));
+      return new Fun.Tuple2<A, B>(
+          provider.getColumnValue(row, 0, p1), provider.getColumnValue(row, 1, p2));
     }
   }
 
@@ -70,7 +68,10 @@ public final class Mappers {
     private final HelenusProperty p2;
     private final HelenusProperty p3;
 
-		public Mapper3(ColumnValueProvider provider, HelenusPropertyNode p1, HelenusPropertyNode p2,
+    public Mapper3(
+        ColumnValueProvider provider,
+        HelenusPropertyNode p1,
+        HelenusPropertyNode p2,
         HelenusPropertyNode p3) {
       this.provider = provider;
       this.p1 = p1.getProperty();
@@ -80,7 +81,9 @@ public final class Mappers {
 
     @Override
     public Fun.Tuple3<A, B, C> apply(Row row) {
-			return new Fun.Tuple3<A, B, C>(provider.getColumnValue(row, 0, p1), provider.getColumnValue(row, 1, p2),
+      return new Fun.Tuple3<A, B, C>(
+          provider.getColumnValue(row, 0, p1),
+          provider.getColumnValue(row, 1, p2),
           provider.getColumnValue(row, 2, p3));
     }
   }
@@ -93,8 +96,12 @@ public final class Mappers {
     private final HelenusProperty p3;
     private final HelenusProperty p4;
 
-		public Mapper4(ColumnValueProvider provider, HelenusPropertyNode p1, HelenusPropertyNode p2,
-				HelenusPropertyNode p3, HelenusPropertyNode p4) {
+    public Mapper4(
+        ColumnValueProvider provider,
+        HelenusPropertyNode p1,
+        HelenusPropertyNode p2,
+        HelenusPropertyNode p3,
+        HelenusPropertyNode p4) {
       this.provider = provider;
       this.p1 = p1.getProperty();
       this.p2 = p2.getProperty();
@@ -104,18 +111,27 @@ public final class Mappers {
 
     @Override
     public Fun.Tuple4<A, B, C, D> apply(Row row) {
-			return new Fun.Tuple4<A, B, C, D>(provider.getColumnValue(row, 0, p1), provider.getColumnValue(row, 1, p2),
-					provider.getColumnValue(row, 2, p3), provider.getColumnValue(row, 3, p4));
+      return new Fun.Tuple4<A, B, C, D>(
+          provider.getColumnValue(row, 0, p1),
+          provider.getColumnValue(row, 1, p2),
+          provider.getColumnValue(row, 2, p3),
+          provider.getColumnValue(row, 3, p4));
     }
   }
 
-	public static final class Mapper5<A, B, C, D, E> implements Function<Row, Fun.Tuple5<A, B, C, D, E>> {
+  public static final class Mapper5<A, B, C, D, E>
+      implements Function<Row, Fun.Tuple5<A, B, C, D, E>> {
 
     private final ColumnValueProvider provider;
     private final HelenusProperty p1, p2, p3, p4, p5;
 
-		public Mapper5(ColumnValueProvider provider, HelenusPropertyNode p1, HelenusPropertyNode p2,
-				HelenusPropertyNode p3, HelenusPropertyNode p4, HelenusPropertyNode p5) {
+    public Mapper5(
+        ColumnValueProvider provider,
+        HelenusPropertyNode p1,
+        HelenusPropertyNode p2,
+        HelenusPropertyNode p3,
+        HelenusPropertyNode p4,
+        HelenusPropertyNode p5) {
       this.provider = provider;
       this.p1 = p1.getProperty();
       this.p2 = p2.getProperty();
@@ -126,19 +142,29 @@ public final class Mappers {
 
     @Override
     public Fun.Tuple5<A, B, C, D, E> apply(Row row) {
-			return new Fun.Tuple5<A, B, C, D, E>(provider.getColumnValue(row, 0, p1),
-					provider.getColumnValue(row, 1, p2), provider.getColumnValue(row, 2, p3),
-					provider.getColumnValue(row, 3, p4), provider.getColumnValue(row, 4, p5));
+      return new Fun.Tuple5<A, B, C, D, E>(
+          provider.getColumnValue(row, 0, p1),
+          provider.getColumnValue(row, 1, p2),
+          provider.getColumnValue(row, 2, p3),
+          provider.getColumnValue(row, 3, p4),
+          provider.getColumnValue(row, 4, p5));
     }
   }
 
-	public static final class Mapper6<A, B, C, D, E, F> implements Function<Row, Fun.Tuple6<A, B, C, D, E, F>> {
+  public static final class Mapper6<A, B, C, D, E, F>
+      implements Function<Row, Fun.Tuple6<A, B, C, D, E, F>> {
 
     private final ColumnValueProvider provider;
     private final HelenusProperty p1, p2, p3, p4, p5, p6;
 
-		public Mapper6(ColumnValueProvider provider, HelenusPropertyNode p1, HelenusPropertyNode p2,
-				HelenusPropertyNode p3, HelenusPropertyNode p4, HelenusPropertyNode p5, HelenusPropertyNode p6) {
+    public Mapper6(
+        ColumnValueProvider provider,
+        HelenusPropertyNode p1,
+        HelenusPropertyNode p2,
+        HelenusPropertyNode p3,
+        HelenusPropertyNode p4,
+        HelenusPropertyNode p5,
+        HelenusPropertyNode p6) {
       this.provider = provider;
       this.p1 = p1.getProperty();
       this.p2 = p2.getProperty();
@@ -150,20 +176,30 @@ public final class Mappers {
 
     @Override
     public Fun.Tuple6<A, B, C, D, E, F> apply(Row row) {
-			return new Fun.Tuple6<A, B, C, D, E, F>(provider.getColumnValue(row, 0, p1),
-					provider.getColumnValue(row, 1, p2), provider.getColumnValue(row, 2, p3),
-					provider.getColumnValue(row, 3, p4), provider.getColumnValue(row, 4, p5),
+      return new Fun.Tuple6<A, B, C, D, E, F>(
+          provider.getColumnValue(row, 0, p1),
+          provider.getColumnValue(row, 1, p2),
+          provider.getColumnValue(row, 2, p3),
+          provider.getColumnValue(row, 3, p4),
+          provider.getColumnValue(row, 4, p5),
           provider.getColumnValue(row, 5, p6));
     }
   }
 
-	public static final class Mapper7<A, B, C, D, E, F, G> implements Function<Row, Fun.Tuple7<A, B, C, D, E, F, G>> {
+  public static final class Mapper7<A, B, C, D, E, F, G>
+      implements Function<Row, Fun.Tuple7<A, B, C, D, E, F, G>> {
 
     private final ColumnValueProvider provider;
     private final HelenusProperty p1, p2, p3, p4, p5, p6, p7;
 
-		public Mapper7(ColumnValueProvider provider, HelenusPropertyNode p1, HelenusPropertyNode p2,
-				HelenusPropertyNode p3, HelenusPropertyNode p4, HelenusPropertyNode p5, HelenusPropertyNode p6,
+    public Mapper7(
+        ColumnValueProvider provider,
+        HelenusPropertyNode p1,
+        HelenusPropertyNode p2,
+        HelenusPropertyNode p3,
+        HelenusPropertyNode p4,
+        HelenusPropertyNode p5,
+        HelenusPropertyNode p6,
         HelenusPropertyNode p7) {
       this.provider = provider;
       this.p1 = p1.getProperty();
@@ -177,10 +213,14 @@ public final class Mappers {
 
     @Override
     public Fun.Tuple7<A, B, C, D, E, F, G> apply(Row row) {
-			return new Fun.Tuple7<A, B, C, D, E, F, G>(provider.getColumnValue(row, 0, p1),
-					provider.getColumnValue(row, 1, p2), provider.getColumnValue(row, 2, p3),
-					provider.getColumnValue(row, 3, p4), provider.getColumnValue(row, 4, p5),
-					provider.getColumnValue(row, 5, p6), provider.getColumnValue(row, 6, p7));
+      return new Fun.Tuple7<A, B, C, D, E, F, G>(
+          provider.getColumnValue(row, 0, p1),
+          provider.getColumnValue(row, 1, p2),
+          provider.getColumnValue(row, 2, p3),
+          provider.getColumnValue(row, 3, p4),
+          provider.getColumnValue(row, 4, p5),
+          provider.getColumnValue(row, 5, p6),
+          provider.getColumnValue(row, 6, p7));
     }
   }
 }

src/main/java/net/helenus/core/Ordered.java

@@ -1,10 +1,8 @@
 package net.helenus.core;
 
-import java.util.Objects;
-
 import com.datastax.driver.core.querybuilder.Ordering;
 import com.datastax.driver.core.querybuilder.QueryBuilder;
-
+import java.util.Objects;
 import net.helenus.core.reflect.HelenusPropertyNode;
 import net.helenus.mapping.ColumnType;
 import net.helenus.mapping.MappingUtil;
@@ -34,10 +32,10 @@ public final class Ordered {
     }
 
     switch (direction) {
-			case ASC :
+      case ASC:
         return QueryBuilder.asc(propNode.getColumnName());
 
-			case DESC :
+      case DESC:
         return QueryBuilder.desc(propNode.getColumnName());
     }
 

src/main/java/net/helenus/core/Postulate.java

@@ -17,7 +17,6 @@ package net.helenus.core;
 
 import com.datastax.driver.core.querybuilder.Clause;
 import com.datastax.driver.core.querybuilder.QueryBuilder;
-
 import net.helenus.core.reflect.HelenusPropertyNode;
 import net.helenus.mapping.value.ColumnValuePreparer;
 import net.helenus.support.HelenusMappingException;
@@ -39,34 +38,34 @@ public final class Postulate<V> {
   public Clause getClause(HelenusPropertyNode node, ColumnValuePreparer valuePreparer) {
 
     switch (operator) {
-			case EQ :
-				return QueryBuilder.eq(node.getColumnName(),
-						valuePreparer.prepareColumnValue(values[0], node.getProperty()));
+      case EQ:
+        return QueryBuilder.eq(
+            node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
 
-			case IN :
+      case IN:
         Object[] preparedValues = new Object[values.length];
         for (int i = 0; i != values.length; ++i) {
           preparedValues[i] = valuePreparer.prepareColumnValue(values[i], node.getProperty());
         }
         return QueryBuilder.in(node.getColumnName(), preparedValues);
 
-			case LT :
-				return QueryBuilder.lt(node.getColumnName(),
-						valuePreparer.prepareColumnValue(values[0], node.getProperty()));
+      case LT:
+        return QueryBuilder.lt(
+            node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
 
-			case LTE :
-				return QueryBuilder.lte(node.getColumnName(),
-						valuePreparer.prepareColumnValue(values[0], node.getProperty()));
+      case LTE:
+        return QueryBuilder.lte(
+            node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
 
-			case GT :
-				return QueryBuilder.gt(node.getColumnName(),
-						valuePreparer.prepareColumnValue(values[0], node.getProperty()));
+      case GT:
+        return QueryBuilder.gt(
+            node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
 
-			case GTE :
-				return QueryBuilder.gte(node.getColumnName(),
-						valuePreparer.prepareColumnValue(values[0], node.getProperty()));
+      case GTE:
+        return QueryBuilder.gte(
+            node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
 
-			default :
+      default:
         throw new HelenusMappingException("unknown filter operation " + operator);
     }
   }

src/main/java/net/helenus/core/Query.java

@@ -15,20 +15,17 @@
  */
 package net.helenus.core;
 
+import com.datastax.driver.core.querybuilder.BindMarker;
+import com.datastax.driver.core.querybuilder.QueryBuilder;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
-
-import com.datastax.driver.core.querybuilder.BindMarker;
-import com.datastax.driver.core.querybuilder.QueryBuilder;
-
 import net.helenus.mapping.OrderingDirection;
 
 /** Sugar methods for the queries */
 public final class Query {
 
-	private Query() {
-	}
+  private Query() {}
 
   public static BindMarker marker() {
     return QueryBuilder.bindMarker();

src/main/java/net/helenus/core/SchemaUtil.java

@@ -15,16 +15,14 @@
  */
 package net.helenus.core;
 
-import java.util.*;
-import java.util.stream.Collectors;
-
 import com.datastax.driver.core.*;
 import com.datastax.driver.core.querybuilder.IsNotNullClause;
 import com.datastax.driver.core.querybuilder.QueryBuilder;
 import com.datastax.driver.core.querybuilder.Select;
 import com.datastax.driver.core.schemabuilder.*;
 import com.datastax.driver.core.schemabuilder.Create.Options;
-
+import java.util.*;
+import java.util.stream.Collectors;
 import net.helenus.core.reflect.HelenusPropertyNode;
 import net.helenus.mapping.*;
 import net.helenus.mapping.ColumnType;
@@ -35,8 +33,7 @@ import net.helenus.support.HelenusMappingException;
 
 public final class SchemaUtil {
 
-	private SchemaUtil() {
-	}
+  private SchemaUtil() {}
 
   public static RegularStatement use(String keyspace, boolean forceQuote) {
     if (forceQuote) {
@@ -59,23 +56,31 @@ public final class SchemaUtil {
       ColumnType columnType = prop.getColumnType();
 
       if (columnType == ColumnType.PARTITION_KEY || columnType == ColumnType.CLUSTERING_COLUMN) {
-				throw new HelenusMappingException("primary key columns are not supported in UserDefinedType for "
-						+ prop.getPropertyName() + " in entity " + entity);
+        throw new HelenusMappingException(
+            "primary key columns are not supported in UserDefinedType for "
+                + prop.getPropertyName()
+                + " in entity "
+                + entity);
       }
 
       try {
         prop.getDataType().addColumn(create, prop.getColumnName());
       } catch (IllegalArgumentException e) {
-				throw new HelenusMappingException("invalid column name '" + prop.getColumnName() + "' in entity '"
-						+ entity.getName().getName() + "'", e);
+        throw new HelenusMappingException(
+            "invalid column name '"
+                + prop.getColumnName()
+                + "' in entity '"
+                + entity.getName().getName()
+                + "'",
+            e);
       }
     }
 
     return create;
   }
 
-	public static List<SchemaStatement> alterUserType(UserType userType, HelenusEntity entity,
-			boolean dropUnusedColumns) {
+  public static List<SchemaStatement> alterUserType(
+      UserType userType, HelenusEntity entity, boolean dropUnusedColumns) {
 
     if (entity.getType() != HelenusEntityType.UDT) {
       throw new HelenusMappingException("expected UDT entity " + entity);
@@ -84,12 +89,13 @@ public final class SchemaUtil {
     List<SchemaStatement> result = new ArrayList<SchemaStatement>();
 
     /**
-		 * TODO: In future replace SchemaBuilder.alterTable by SchemaBuilder.alterType
-		 * when it will exist
+     * TODO: In future replace SchemaBuilder.alterTable by SchemaBuilder.alterType when it will
+     * exist
      */
     Alter alter = SchemaBuilder.alterTable(entity.getName().toCql());
 
-		final Set<String> visitedColumns = dropUnusedColumns ? new HashSet<String>() : Collections.<String>emptySet();
+    final Set<String> visitedColumns =
+        dropUnusedColumns ? new HashSet<String>() : Collections.<String>emptySet();
 
     for (HelenusProperty prop : entity.getOrderedProperties()) {
 
@@ -106,8 +112,9 @@ public final class SchemaUtil {
       }
 
       DataType dataType = userType.getFieldType(columnName);
-			SchemaStatement stmt = prop.getDataType().alterColumn(alter, prop.getColumnName(),
-					optional(columnName, dataType));
+      SchemaStatement stmt =
+          prop.getDataType()
+              .alterColumn(alter, prop.getColumnName(), optional(columnName, dataType));
 
       if (stmt != null) {
         result.add(stmt);
@@ -147,28 +154,36 @@ public final class SchemaUtil {
     for (HelenusProperty prop : properties) {
       String columnName = prop.getColumnName().toCql();
       switch (prop.getColumnType()) {
-				case PARTITION_KEY :
+        case PARTITION_KEY:
           p.add(columnName);
           break;
-				case CLUSTERING_COLUMN :
+        case CLUSTERING_COLUMN:
           c.add(columnName);
           break;
-				default :
+        default:
           break;
       }
     }
 
-		return "(" + ((p.size() > 1) ? "(" + String.join(", ", p) + ")" : p.get(0))
-				+ ((c.size() > 0) ? ", " + ((c.size() > 1) ? "(" + String.join(", ", c) + ")" : c.get(0)) : "") + ")";
+    return "("
+        + ((p.size() > 1) ? "(" + String.join(", ", p) + ")" : p.get(0))
+        + ((c.size() > 0)
+            ? ", " + ((c.size() > 1) ? "(" + String.join(", ", c) + ")" : c.get(0))
+            : "")
+        + ")";
   }
 
-	public static SchemaStatement createMaterializedView(String keyspace, String viewName, HelenusEntity entity) {
+  public static SchemaStatement createMaterializedView(
+      String keyspace, String viewName, HelenusEntity entity) {
     if (entity.getType() != HelenusEntityType.VIEW) {
       throw new HelenusMappingException("expected view entity " + entity);
     }
 
     List<HelenusPropertyNode> props = new ArrayList<HelenusPropertyNode>();
-		entity.getOrderedProperties().stream().map(p -> new HelenusPropertyNode(p, Optional.empty()))
+    entity
+        .getOrderedProperties()
+        .stream()
+        .map(p -> new HelenusPropertyNode(p, Optional.empty()))
         .forEach(p -> props.add(p));
 
     Select.Selection selection = QueryBuilder.select();
@@ -185,20 +200,20 @@ public final class SchemaUtil {
     for (HelenusPropertyNode prop : props) {
       String columnName = prop.getColumnName();
       switch (prop.getProperty().getColumnType()) {
-				case PARTITION_KEY :
+        case PARTITION_KEY:
           where = where.and(new IsNotNullClause(columnName));
           break;
 
-				case CLUSTERING_COLUMN :
+        case CLUSTERING_COLUMN:
           where = where.and(new IsNotNullClause(columnName));
 
-					ClusteringColumn clusteringColumn = prop.getProperty().getGetterMethod()
-							.getAnnotation(ClusteringColumn.class);
+          ClusteringColumn clusteringColumn =
+              prop.getProperty().getGetterMethod().getAnnotation(ClusteringColumn.class);
           if (clusteringColumn != null && clusteringColumn.ordering() != null) {
             o.add(columnName + " " + clusteringColumn.ordering().cql());
           }
           break;
-				default :
+        default:
           break;
       }
     }
@@ -209,10 +224,12 @@ public final class SchemaUtil {
     if (o.size() > 0) {
       clustering = "WITH CLUSTERING ORDER BY (" + String.join(", ", o) + ")";
     }
-		return new CreateMaterializedView(keyspace, viewName, where, primaryKey, clustering).ifNotExists();
+    return new CreateMaterializedView(keyspace, viewName, where, primaryKey, clustering)
+        .ifNotExists();
   }
 
-	public static SchemaStatement dropMaterializedView(String keyspace, String viewName, HelenusEntity entity) {
+  public static SchemaStatement dropMaterializedView(
+      String keyspace, String viewName, HelenusEntity entity) {
     return new DropMaterializedView(keyspace, viewName);
   }
 
@@ -245,14 +262,15 @@ public final class SchemaUtil {
 
     if (!clusteringColumns.isEmpty()) {
       Options options = create.withOptions();
-			clusteringColumns
-					.forEach(p -> options.clusteringOrder(p.getColumnName().toCql(), mapDirection(p.getOrdering())));
+      clusteringColumns.forEach(
+          p -> options.clusteringOrder(p.getColumnName().toCql(), mapDirection(p.getOrdering())));
     }
 
     return create;
   }
 
-	public static List<SchemaStatement> alterTable(TableMetadata tmd, HelenusEntity entity, boolean dropUnusedColumns) {
+  public static List<SchemaStatement> alterTable(
+      TableMetadata tmd, HelenusEntity entity, boolean dropUnusedColumns) {
 
     if (entity.getType() != HelenusEntityType.TABLE) {
       throw new HelenusMappingException("expected table entity " + entity);
@@ -262,7 +280,8 @@ public final class SchemaUtil {
 
     Alter alter = SchemaBuilder.alterTable(entity.getName().toCql());
 
-		final Set<String> visitedColumns = dropUnusedColumns ? new HashSet<String>() : Collections.<String>emptySet();
+    final Set<String> visitedColumns =
+        dropUnusedColumns ? new HashSet<String>() : Collections.<String>emptySet();
 
     for (HelenusProperty prop : entity.getOrderedProperties()) {
 
@@ -279,8 +298,8 @@ public final class SchemaUtil {
       }
 
       ColumnMetadata columnMetadata = tmd.getColumn(columnName);
-			SchemaStatement stmt = prop.getDataType().alterColumn(alter, prop.getColumnName(),
-					optional(columnMetadata));
+      SchemaStatement stmt =
+          prop.getDataType().alterColumn(alter, prop.getColumnName(), optional(columnMetadata));
 
       if (stmt != null) {
         result.add(stmt);
@@ -310,28 +329,42 @@ public final class SchemaUtil {
 
   public static SchemaStatement createIndex(HelenusProperty prop) {
     if (prop.caseSensitiveIndex()) {
-			return SchemaBuilder.createIndex(prop.getIndexName().get().toCql()).ifNotExists()
-					.onTable(prop.getEntity().getName().toCql()).andColumn(prop.getColumnName().toCql());
+      return SchemaBuilder.createIndex(prop.getIndexName().get().toCql())
+          .ifNotExists()
+          .onTable(prop.getEntity().getName().toCql())
+          .andColumn(prop.getColumnName().toCql());
     } else {
-			return new CreateSasiIndex(prop.getIndexName().get().toCql()).ifNotExists()
-					.onTable(prop.getEntity().getName().toCql()).andColumn(prop.getColumnName().toCql());
+      return new CreateSasiIndex(prop.getIndexName().get().toCql())
+          .ifNotExists()
+          .onTable(prop.getEntity().getName().toCql())
+          .andColumn(prop.getColumnName().toCql());
     }
   }
 
   public static List<SchemaStatement> createIndexes(HelenusEntity entity) {
 
-		return entity.getOrderedProperties().stream().filter(p -> p.getIndexName().isPresent())
-				.map(p -> SchemaUtil.createIndex(p)).collect(Collectors.toList());
+    return entity
+        .getOrderedProperties()
+        .stream()
+        .filter(p -> p.getIndexName().isPresent())
+        .map(p -> SchemaUtil.createIndex(p))
+        .collect(Collectors.toList());
   }
 
-	public static List<SchemaStatement> alterIndexes(TableMetadata tmd, HelenusEntity entity,
-			boolean dropUnusedIndexes) {
+  public static List<SchemaStatement> alterIndexes(
+      TableMetadata tmd, HelenusEntity entity, boolean dropUnusedIndexes) {
 
     List<SchemaStatement> list = new ArrayList<SchemaStatement>();
 
-		final Set<String> visitedColumns = dropUnusedIndexes ? new HashSet<String>() : Collections.<String>emptySet();
+    final Set<String> visitedColumns =
+        dropUnusedIndexes ? new HashSet<String>() : Collections.<String>emptySet();
 
-		entity.getOrderedProperties().stream().filter(p -> p.getIndexName().isPresent()).forEach(p -> {
+    entity
+        .getOrderedProperties()
+        .stream()
+        .filter(p -> p.getIndexName().isPresent())
+        .forEach(
+            p -> {
               String columnName = p.getColumnName().getName();
 
               if (dropUnusedIndexes) {
@@ -352,9 +385,11 @@ public final class SchemaUtil {
 
     if (dropUnusedIndexes) {
 
-			tmd.getColumns().stream()
+      tmd.getColumns()
+          .stream()
           .filter(c -> tmd.getIndex(c.getName()) != null && !visitedColumns.contains(c.getName()))
-					.forEach(c -> {
+          .forEach(
+              c -> {
                 list.add(SchemaBuilder.dropIndex(tmd.getIndex(c.getName()).getName()).ifExists());
               });
     }
@@ -368,9 +403,9 @@ public final class SchemaUtil {
 
   private static SchemaBuilder.Direction mapDirection(OrderingDirection o) {
     switch (o) {
-			case ASC :
+      case ASC:
         return SchemaBuilder.Direction.ASC;
-			case DESC :
+      case DESC:
         return SchemaBuilder.Direction.DESC;
     }
     throw new HelenusMappingException("unknown ordering " + o);
@@ -380,7 +415,10 @@ public final class SchemaUtil {
 
     throw new HelenusMappingException(
         "only primitive types and Set,List,Map collections and UserDefinedTypes are allowed, unknown type for property '"
-						+ prop.getPropertyName() + "' type is '" + prop.getJavaType() + "' in the entity "
+            + prop.getPropertyName()
+            + "' type is '"
+            + prop.getJavaType()
+            + "' in the entity "
             + prop.getEntity());
   }
 

src/main/java/net/helenus/core/SessionInitializer.java

@@ -15,18 +15,16 @@
  */
 package net.helenus.core;
 
+import brave.Tracer;
+import com.codahale.metrics.MetricRegistry;
+import com.datastax.driver.core.*;
+import com.google.common.util.concurrent.MoreExecutors;
 import java.io.IOException;
 import java.io.PrintStream;
 import java.util.*;
 import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.function.Consumer;
-
-import com.codahale.metrics.MetricRegistry;
-import com.datastax.driver.core.*;
-import com.google.common.util.concurrent.MoreExecutors;
-
-import brave.Tracer;
 import net.helenus.core.cache.SessionCache;
 import net.helenus.core.reflect.DslExportable;
 import net.helenus.mapping.HelenusEntity;
@@ -186,8 +184,11 @@ public final class SessionInitializer extends AbstractSessionOperations {
 
   public SessionInitializer addPackage(String packageName) {
     try {
-			PackageUtil.getClasses(packageName).stream().filter(c -> c.isInterface() && !c.isAnnotation())
-					.forEach(clazz -> {
+      PackageUtil.getClasses(packageName)
+          .stream()
+          .filter(c -> c.isInterface() && !c.isAnnotation())
+          .forEach(
+              clazz -> {
                 initList.add(Either.right(clazz));
               });
     } catch (IOException | ClassNotFoundException e) {
@@ -249,16 +250,29 @@ public final class SessionInitializer extends AbstractSessionOperations {
 
   public synchronized HelenusSession get() {
     initialize();
-		return new HelenusSession(session, usingKeyspace, registry, showCql, printStream, sessionRepository, executor,
-				autoDdl == AutoDdl.CREATE_DROP, consistencyLevel, idempotent, unitOfWorkClass, sessionCache,
-				metricRegistry, zipkinTracer);
+    return new HelenusSession(
+        session,
+        usingKeyspace,
+        registry,
+        showCql,
+        printStream,
+        sessionRepository,
+        executor,
+        autoDdl == AutoDdl.CREATE_DROP,
+        consistencyLevel,
+        idempotent,
+        unitOfWorkClass,
+        sessionCache,
+        metricRegistry,
+        zipkinTracer);
   }
 
   private void initialize() {
 
     Objects.requireNonNull(usingKeyspace, "please define keyspace by 'use' operator");
 
-		initList.forEach((either) -> {
+    initList.forEach(
+        (either) -> {
           Class<?> iface = null;
           if (either.isLeft()) {
             iface = MappingUtil.getMappingInterface(either.getLeft());
@@ -275,53 +289,77 @@ public final class SessionInitializer extends AbstractSessionOperations {
     UserTypeOperations userTypeOps = new UserTypeOperations(this, dropUnusedColumns);
 
     switch (autoDdl) {
-			case CREATE_DROP :
+      case CREATE_DROP:
 
         // Drop view first, otherwise a `DROP TABLE ...` will fail as the type is still
         // referenced
         // by a view.
-				sessionRepository.entities().stream().filter(e -> e.getType() == HelenusEntityType.VIEW)
+        sessionRepository
+            .entities()
+            .stream()
+            .filter(e -> e.getType() == HelenusEntityType.VIEW)
             .forEach(e -> tableOps.dropView(e));
 
         // Drop tables second, before DROP TYPE otherwise a `DROP TYPE ...` will fail as
         // the type is
         // still referenced by a table.
-				sessionRepository.entities().stream().filter(e -> e.getType() == HelenusEntityType.TABLE)
+        sessionRepository
+            .entities()
+            .stream()
+            .filter(e -> e.getType() == HelenusEntityType.TABLE)
             .forEach(e -> tableOps.dropTable(e));
 
         eachUserTypeInReverseOrder(userTypeOps, e -> userTypeOps.dropUserType(e));
 
         // FALLTHRU to CREATE case (read: the absence of a `break;` statement here is
         // intentional!)
-			case CREATE :
+      case CREATE:
         eachUserTypeInOrder(userTypeOps, e -> userTypeOps.createUserType(e));
 
-				sessionRepository.entities().stream().filter(e -> e.getType() == HelenusEntityType.TABLE)
+        sessionRepository
+            .entities()
+            .stream()
+            .filter(e -> e.getType() == HelenusEntityType.TABLE)
             .forEach(e -> tableOps.createTable(e));
 
-				sessionRepository.entities().stream().filter(e -> e.getType() == HelenusEntityType.VIEW)
+        sessionRepository
+            .entities()
+            .stream()
+            .filter(e -> e.getType() == HelenusEntityType.VIEW)
             .forEach(e -> tableOps.createView(e));
 
         break;
 
-			case VALIDATE :
+      case VALIDATE:
         eachUserTypeInOrder(userTypeOps, e -> userTypeOps.validateUserType(getUserType(e), e));
 
-				sessionRepository.entities().stream().filter(e -> e.getType() == HelenusEntityType.TABLE)
+        sessionRepository
+            .entities()
+            .stream()
+            .filter(e -> e.getType() == HelenusEntityType.TABLE)
             .forEach(e -> tableOps.validateTable(getTableMetadata(e), e));
 
         break;
 
-			case UPDATE :
+      case UPDATE:
         eachUserTypeInOrder(userTypeOps, e -> userTypeOps.updateUserType(getUserType(e), e));
 
-				sessionRepository.entities().stream().filter(e -> e.getType() == HelenusEntityType.VIEW)
+        sessionRepository
+            .entities()
+            .stream()
+            .filter(e -> e.getType() == HelenusEntityType.VIEW)
             .forEach(e -> tableOps.dropView(e));
 
-				sessionRepository.entities().stream().filter(e -> e.getType() == HelenusEntityType.TABLE)
+        sessionRepository
+            .entities()
+            .stream()
+            .filter(e -> e.getType() == HelenusEntityType.TABLE)
             .forEach(e -> tableOps.updateTable(getTableMetadata(e), e));
 
-				sessionRepository.entities().stream().filter(e -> e.getType() == HelenusEntityType.VIEW)
+        sessionRepository
+            .entities()
+            .stream()
+            .filter(e -> e.getType() == HelenusEntityType.VIEW)
             .forEach(e -> tableOps.createView(e));
         break;
     }
@@ -333,27 +371,41 @@ public final class SessionInitializer extends AbstractSessionOperations {
     }
   }
 
-	private void eachUserTypeInOrder(UserTypeOperations userTypeOps, Consumer<? super HelenusEntity> action) {
+  private void eachUserTypeInOrder(
+      UserTypeOperations userTypeOps, Consumer<? super HelenusEntity> action) {
 
     Set<HelenusEntity> processedSet = new HashSet<HelenusEntity>();
     Set<HelenusEntity> stack = new HashSet<HelenusEntity>();
 
-		sessionRepository.entities().stream().filter(e -> e.getType() == HelenusEntityType.UDT).forEach(e -> {
+    sessionRepository
+        .entities()
+        .stream()
+        .filter(e -> e.getType() == HelenusEntityType.UDT)
+        .forEach(
+            e -> {
               stack.clear();
               eachUserTypeInRecursion(e, processedSet, stack, userTypeOps, action);
             });
   }
 
-	private void eachUserTypeInReverseOrder(UserTypeOperations userTypeOps, Consumer<? super HelenusEntity> action) {
+  private void eachUserTypeInReverseOrder(
+      UserTypeOperations userTypeOps, Consumer<? super HelenusEntity> action) {
     ArrayDeque<HelenusEntity> deque = new ArrayDeque<>();
     eachUserTypeInOrder(userTypeOps, e -> deque.addFirst(e));
-		deque.stream().forEach(e -> {
+    deque
+        .stream()
+        .forEach(
+            e -> {
               action.accept(e);
             });
   }
 
-	private void eachUserTypeInRecursion(HelenusEntity e, Set<HelenusEntity> processedSet, Set<HelenusEntity> stack,
-			UserTypeOperations userTypeOps, Consumer<? super HelenusEntity> action) {
+  private void eachUserTypeInRecursion(
+      HelenusEntity e,
+      Set<HelenusEntity> processedSet,
+      Set<HelenusEntity> stack,
+      UserTypeOperations userTypeOps,
+      Consumer<? super HelenusEntity> action) {
 
     stack.add(e);
 
@@ -374,7 +426,8 @@ public final class SessionInitializer extends AbstractSessionOperations {
 
   private KeyspaceMetadata getKeyspaceMetadata() {
     if (keyspaceMetadata == null) {
-			keyspaceMetadata = session.getCluster().getMetadata().getKeyspace(usingKeyspace.toLowerCase());
+      keyspaceMetadata =
+          session.getCluster().getMetadata().getKeyspace(usingKeyspace.toLowerCase());
     }
     return keyspaceMetadata;
   }

src/main/java/net/helenus/core/SessionRepository.java

@@ -15,11 +15,9 @@
  */
 package net.helenus.core;
 
-import java.util.Collection;
-
 import com.datastax.driver.core.UserType;
 import com.google.common.collect.ImmutableMap;
-
+import java.util.Collection;
 import net.helenus.mapping.HelenusEntity;
 
 public final class SessionRepository {
@@ -32,7 +30,8 @@ public final class SessionRepository {
 
     userTypeMap = ImmutableMap.<String, UserType>builder().putAll(builder.getUserTypeMap()).build();
 
-		entityMap = ImmutableMap.<Class<?>, HelenusEntity>builder().putAll(builder.getEntityMap()).build();
+    entityMap =
+        ImmutableMap.<Class<?>, HelenusEntity>builder().putAll(builder.getEntityMap()).build();
   }
 
   public UserType findUserType(String name) {

src/main/java/net/helenus/core/SessionRepositoryBuilder.java

@@ -15,17 +15,15 @@
  */
 package net.helenus.core;
 
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-
 import com.datastax.driver.core.Session;
 import com.datastax.driver.core.UDTValue;
 import com.datastax.driver.core.UserType;
 import com.google.common.collect.HashMultimap;
 import com.google.common.collect.Multimap;
-
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
 import net.helenus.mapping.HelenusEntity;
 import net.helenus.mapping.HelenusEntityType;
 import net.helenus.mapping.HelenusProperty;
@@ -35,7 +33,8 @@ import net.helenus.support.HelenusMappingException;
 
 public final class SessionRepositoryBuilder {
 
-	private static final Optional<HelenusEntityType> OPTIONAL_UDT = Optional.of(HelenusEntityType.UDT);
+  private static final Optional<HelenusEntityType> OPTIONAL_UDT =
+      Optional.of(HelenusEntityType.UDT);
 
   private final Map<Class<?>, HelenusEntity> entityMap = new HashMap<Class<?>, HelenusEntity>();
 
@@ -99,7 +98,8 @@ public final class SessionRepositoryBuilder {
       entity = helenusEntity;
 
       if (type.isPresent() && entity.getType() != type.get()) {
-				throw new HelenusMappingException("unexpected entity type " + entity.getType() + " for " + entity);
+        throw new HelenusMappingException(
+            "unexpected entity type " + entity.getType() + " for " + entity);
       }
 
       HelenusEntity concurrentEntity = entityMap.putIfAbsent(iface, entity);

src/main/java/net/helenus/core/TableOperations.java

@@ -15,11 +15,9 @@
  */
 package net.helenus.core;
 
-import java.util.List;
-
 import com.datastax.driver.core.TableMetadata;
 import com.datastax.driver.core.schemabuilder.SchemaStatement;
-
+import java.util.List;
 import net.helenus.mapping.HelenusEntity;
 import net.helenus.support.HelenusException;
 
@@ -29,7 +27,8 @@ public final class TableOperations {
   private final boolean dropUnusedColumns;
   private final boolean dropUnusedIndexes;
 
-	public TableOperations(AbstractSessionOperations sessionOps, boolean dropUnusedColumns, boolean dropUnusedIndexes) {
+  public TableOperations(
+      AbstractSessionOperations sessionOps, boolean dropUnusedColumns, boolean dropUnusedIndexes) {
     this.sessionOps = sessionOps;
     this.dropUnusedColumns = dropUnusedColumns;
     this.dropUnusedIndexes = dropUnusedIndexes;
@@ -48,7 +47,10 @@ public final class TableOperations {
 
     if (tmd == null) {
       throw new HelenusException(
-					"table does not exists " + entity.getName() + "for entity " + entity.getMappingInterface());
+          "table does not exists "
+              + entity.getName()
+              + "for entity "
+              + entity.getMappingInterface());
     }
 
     List<SchemaStatement> list = SchemaUtil.alterTable(tmd, entity, dropUnusedColumns);
@@ -57,7 +59,10 @@ public final class TableOperations {
 
     if (!list.isEmpty()) {
       throw new HelenusException(
-					"schema changed for entity " + entity.getMappingInterface() + ", apply this command: " + list);
+          "schema changed for entity "
+              + entity.getMappingInterface()
+              + ", apply this command: "
+              + list);
     }
   }
 
@@ -73,14 +78,18 @@ public final class TableOperations {
 
   public void createView(HelenusEntity entity) {
     sessionOps.execute(
-				SchemaUtil.createMaterializedView(sessionOps.usingKeyspace(), entity.getName().toCql(), entity), true);
+        SchemaUtil.createMaterializedView(
+            sessionOps.usingKeyspace(), entity.getName().toCql(), entity),
+        true);
     // executeBatch(SchemaUtil.createIndexes(entity)); NOTE: Unfortunately C* 3.10
     // does not yet support 2i on materialized views.
   }
 
   public void dropView(HelenusEntity entity) {
     sessionOps.execute(
-				SchemaUtil.dropMaterializedView(sessionOps.usingKeyspace(), entity.getName().toCql(), entity), true);
+        SchemaUtil.dropMaterializedView(
+            sessionOps.usingKeyspace(), entity.getName().toCql(), entity),
+        true);
   }
 
   public void updateView(TableMetadata tmd, HelenusEntity entity) {
@@ -95,7 +104,8 @@ public final class TableOperations {
 
   private void executeBatch(List<SchemaStatement> list) {
 
-		list.forEach(s -> {
+    list.forEach(
+        s -> {
           sessionOps.execute(s, true);
         });
   }

src/main/java/net/helenus/core/UnitOfWork.java

@@ -15,11 +15,9 @@
  */
 package net.helenus.core;
 
+import com.google.common.base.Stopwatch;
 import java.util.List;
 import java.util.Optional;
-
-import com.google.common.base.Stopwatch;
-
 import net.helenus.core.cache.Facet;
 
 public interface UnitOfWork<X extends Exception> extends AutoCloseable {
@@ -35,19 +33,16 @@ public interface UnitOfWork<X extends Exception> extends AutoCloseable {
   void addNestedUnitOfWork(UnitOfWork<X> uow);
 
   /**
-	 * Checks to see if the work performed between calling begin and now can be
-	 * committed or not.
+   * Checks to see if the work performed between calling begin and now can be committed or not.
    *
-	 * @return a function from which to chain work that only happens when commit is
-	 *         successful
-	 * @throws X
-	 *             when the work overlaps with other concurrent writers.
+   * @return a function from which to chain work that only happens when commit is successful
+   * @throws X when the work overlaps with other concurrent writers.
    */
   PostCommitFunction<Void, Void> commit() throws X;
 
   /**
-	 * Explicitly abort the work within this unit of work. Any nested aborted unit
-	 * of work will trigger the entire unit of work to commit.
+   * Explicitly abort the work within this unit of work. Any nested aborted unit of work will
+   * trigger the entire unit of work to commit.
    */
   void abort();
 
@@ -62,13 +57,15 @@ public interface UnitOfWork<X extends Exception> extends AutoCloseable {
   List<Facet> cacheEvict(List<Facet> facets);
 
   String getPurpose();
+
   UnitOfWork setPurpose(String purpose);
+
   void setInfo(String info);
 
   void addDatabaseTime(String name, Stopwatch amount);
+
   void addCacheLookupTime(Stopwatch amount);
 
   // Cache > 0 means "cache hit", < 0 means cache miss.
   void recordCacheAndDatabaseOperationCount(int cache, int database);
-
 }

src/main/java/net/helenus/core/UserTypeOperations.java

@@ -15,11 +15,9 @@
  */
 package net.helenus.core;
 
-import java.util.List;
-
 import com.datastax.driver.core.UserType;
 import com.datastax.driver.core.schemabuilder.SchemaStatement;
-
+import java.util.List;
 import net.helenus.mapping.HelenusEntity;
 import net.helenus.support.HelenusException;
 
@@ -54,7 +52,10 @@ public final class UserTypeOperations {
 
     if (!list.isEmpty()) {
       throw new HelenusException(
-					"schema changed for entity " + entity.getMappingInterface() + ", apply this command: " + list);
+          "schema changed for entity "
+              + entity.getMappingInterface()
+              + ", apply this command: "
+              + list);
     }
   }
 
@@ -70,7 +71,8 @@ public final class UserTypeOperations {
 
   private void executeBatch(List<SchemaStatement> list) {
 
-		list.forEach(s -> {
+    list.forEach(
+        s -> {
           sessionOps.execute(s, true);
         });
   }

src/main/java/net/helenus/core/annotation/Cacheable.java

@@ -22,5 +22,4 @@ import java.lang.annotation.Target;
 
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.TYPE)
-public @interface Cacheable {
-}
+public @interface Cacheable {}

src/main/java/net/helenus/core/annotation/Retry.java

@@ -21,14 +21,15 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import java.util.concurrent.TimeoutException;
-
 import net.helenus.core.ConflictingUnitOfWorkException;
 
 @Retention(RetentionPolicy.RUNTIME)
 @Target(ElementType.METHOD)
 public @interface Retry {
 
-	Class<? extends Exception>[] on() default {ConflictingUnitOfWorkException.class, TimeoutException.class};
+  Class<? extends Exception>[] on() default {
+    ConflictingUnitOfWorkException.class, TimeoutException.class
+  };
 
   int times() default 3;
 }

src/main/java/net/helenus/core/aspect/RetryAspect.java

@@ -18,7 +18,7 @@ package net.helenus.core.aspect;
 
 import java.lang.reflect.Method;
 import java.util.Arrays;
-
+import net.helenus.core.annotation.Retry;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
@@ -29,8 +29,6 @@ import org.slf4j.LoggerFactory;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.util.Assert;
 
-import net.helenus.core.annotation.Retry;
-
 @Aspect
 public class RetryAspect {
 
@@ -55,8 +53,8 @@ public class RetryAspect {
     return tryProceeding(pjp, times, retryOn);
   }
 
-	private Object tryProceeding(ProceedingJoinPoint pjp, int times, Class<? extends Throwable>[] retryOn)
-			throws Throwable {
+  private Object tryProceeding(
+      ProceedingJoinPoint pjp, int times, Class<? extends Throwable>[] retryOn) throws Throwable {
     try {
       return proceed(pjp);
     } catch (Throwable throwable) {

src/main/java/net/helenus/core/aspect/RetryConcurrentUnitOfWorkAspect.java

@@ -2,7 +2,7 @@ package net.helenus.core.aspect;
 
 import java.lang.reflect.Method;
 import java.util.Arrays;
-
+import net.helenus.core.annotation.Retry;
 import org.apache.commons.lang3.exception.ExceptionUtils;
 import org.aspectj.lang.ProceedingJoinPoint;
 import org.aspectj.lang.annotation.Around;
@@ -13,8 +13,6 @@ import org.slf4j.LoggerFactory;
 import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.util.Assert;
 
-import net.helenus.core.annotation.Retry;
-
 @Aspect
 public class RetryConcurrentUnitOfWorkAspect {
 
@@ -39,8 +37,8 @@ public class RetryConcurrentUnitOfWorkAspect {
     return tryProceeding(pjp, times, retryOn);
   }
 
-	private Object tryProceeding(ProceedingJoinPoint pjp, int times, Class<? extends Throwable>[] retryOn)
-			throws Throwable {
+  private Object tryProceeding(
+      ProceedingJoinPoint pjp, int times, Class<? extends Throwable>[] retryOn) throws Throwable {
     try {
       return proceed(pjp);
     } catch (Throwable throwable) {

src/main/java/net/helenus/core/cache/BoundFacet.java

@@ -18,7 +18,6 @@ package net.helenus.core.cache;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.stream.Collectors;
-
 import net.helenus.mapping.HelenusProperty;
 
 public class BoundFacet extends Facet<String> {
@@ -31,15 +30,25 @@ public class BoundFacet extends Facet<String> {
   }
 
   public BoundFacet(String name, Map<HelenusProperty, Object> properties) {
-		super(name,
+    super(
+        name,
         (properties.keySet().size() > 1)
-						? "[" + String.join(", ",
-								properties.keySet().stream().map(key -> properties.get(key).toString())
+            ? "["
+                + String.join(
+                    ", ",
+                    properties
+                        .keySet()
+                        .stream()
+                        .map(key -> properties.get(key).toString())
                         .collect(Collectors.toSet()))
                 + "]"
-						: String.join("", properties.keySet().stream().map(key -> properties.get(key).toString())
+            : String.join(
+                "",
+                properties
+                    .keySet()
+                    .stream()
+                    .map(key -> properties.get(key).toString())
                     .collect(Collectors.toSet())));
     this.properties = properties;
   }
-
 }

src/main/java/net/helenus/core/cache/CacheUtil.java

@@ -8,8 +8,7 @@ public class CacheUtil {
 
   public static List<String[]> combinations(List<String> items) {
     int n = items.size();
-		if (n > 20)
-			throw new IllegalArgumentException(n + " is out of range");
+    if (n > 20) throw new IllegalArgumentException(n + " is out of range");
     long e = Math.round(Math.pow(2, n));
     List<String[]> out = new ArrayList<String[]>((int) e - 1);
     for (int k = 1; k <= items.size(); k++) {
@@ -18,7 +17,8 @@ public class CacheUtil {
     return out;
   }
 
-	private static void kCombinations(List<String> items, int n, int k, String[] arr, List<String[]> out) {
+  private static void kCombinations(
+      List<String> items, int n, int k, String[] arr, List<String[]> out) {
     if (k == 0) {
       out.add(arr.clone());
     } else {
@@ -30,10 +30,17 @@ public class CacheUtil {
   }
 
   public static List<String[]> flattenFacets(List<Facet> facets) {
-		List<String[]> combinations = CacheUtil.combinations(
-				facets.stream().filter(facet -> !facet.fixed()).filter(facet -> facet.value() != null).map(facet -> {
+    List<String[]> combinations =
+        CacheUtil.combinations(
+            facets
+                .stream()
+                .filter(facet -> !facet.fixed())
+                .filter(facet -> facet.value() != null)
+                .map(
+                    facet -> {
                       return facet.name() + "==" + facet.value();
-				}).collect(Collectors.toList()));
+                    })
+                .collect(Collectors.toList()));
     return combinations;
   }
 
@@ -57,8 +64,10 @@ public class CacheUtil {
   }
 
   public static String schemaName(List<Facet> facets) {
-		return facets.stream().filter(Facet::fixed).map(facet -> facet.value().toString())
+    return facets
+        .stream()
+        .filter(Facet::fixed)
+        .map(facet -> facet.value().toString())
         .collect(Collectors.joining("."));
   }
-
 }

src/main/java/net/helenus/core/cache/Facet.java

@@ -16,9 +16,7 @@
 
 package net.helenus.core.cache;
 
-/**
- * An Entity is identifiable via one or more Facets
- */
+/** An Entity is identifiable via one or more Facets */
 public class Facet<T> {
   private final String name;
   private T value;
@@ -49,5 +47,4 @@ public class Facet<T> {
   public boolean fixed() {
     return fixed;
   }
-
 }

src/main/java/net/helenus/core/cache/GuavaCache.java

@@ -40,5 +40,4 @@ public class GuavaCache<K, V> implements SessionCache<K, V> {
   public void put(K key, V value) {
     cache.put(key, value);
   }
-
 }

src/main/java/net/helenus/core/cache/SessionCache.java

@@ -16,14 +16,12 @@
 
 package net.helenus.core.cache;
 
-import java.util.concurrent.TimeUnit;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.google.common.cache.CacheBuilder;
 import com.google.common.cache.RemovalListener;
 import com.google.common.cache.RemovalNotification;
+import java.util.concurrent.TimeUnit;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public interface SessionCache<K, V> {
 
@@ -31,7 +29,8 @@ public interface SessionCache<K, V> {
 
   static <K, V> SessionCache<K, V> defaultCache() {
     GuavaCache<K, V> cache;
-		RemovalListener<K, V> listener = new RemovalListener<K, V>() {
+    RemovalListener<K, V> listener =
+        new RemovalListener<K, V>() {
           @Override
           public void onRemoval(RemovalNotification<K, V> n) {
             if (n.wasEvicted()) {
@@ -41,13 +40,21 @@ public interface SessionCache<K, V> {
           }
         };
 
-		cache = new GuavaCache<K, V>(CacheBuilder.newBuilder().maximumSize(25_000)
-				.expireAfterAccess(5, TimeUnit.MINUTES).softValues().removalListener(listener).build());
+    cache =
+        new GuavaCache<K, V>(
+            CacheBuilder.newBuilder()
+                .maximumSize(25_000)
+                .expireAfterAccess(5, TimeUnit.MINUTES)
+                .softValues()
+                .removalListener(listener)
+                .build());
 
     return cache;
   }
 
   void invalidate(K key);
+
   V get(K key);
+
   void put(K key, V value);
 }

src/main/java/net/helenus/core/cache/UnboundFacet.java

@@ -19,7 +19,6 @@ import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-
 import net.helenus.core.SchemaUtil;
 import net.helenus.mapping.HelenusProperty;
 

src/main/java/net/helenus/core/operation/AbstractFilterOperation.java

@@ -16,15 +16,13 @@
 package net.helenus.core.operation;
 
 import java.util.*;
-
 import net.helenus.core.*;
 import net.helenus.core.cache.Facet;
 import net.helenus.core.cache.UnboundFacet;
 import net.helenus.mapping.HelenusProperty;
 
 public abstract class AbstractFilterOperation<E, O extends AbstractFilterOperation<E, O>>
-		extends
-			AbstractOperation<E, O> {
+    extends AbstractOperation<E, O> {
 
   protected List<Filter<?>> filters = null;
   protected List<Filter<?>> ifFilters = null;
@@ -133,7 +131,6 @@ public abstract class AbstractFilterOperation<E, O extends AbstractFilterOperati
               }
             }
           }
-
         }
         if (binder.isBound()) {
           boundFacets.add(binder.bind());

src/main/java/net/helenus/core/operation/AbstractFilterOptionalOperation.java

@@ -19,13 +19,12 @@ import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-
 import net.helenus.core.*;
 import net.helenus.mapping.HelenusProperty;
 
-public abstract class AbstractFilterOptionalOperation<E, O extends AbstractFilterOptionalOperation<E, O>>
-		extends
-			AbstractOptionalOperation<E, O> {
+public abstract class AbstractFilterOptionalOperation<
+        E, O extends AbstractFilterOptionalOperation<E, O>>
+    extends AbstractOptionalOperation<E, O> {
 
   protected Map<HelenusProperty, Filter<?>> filters = null;
   protected List<Filter<?>> ifFilters = null;

src/main/java/net/helenus/core/operation/AbstractFilterStreamOperation.java

@@ -19,13 +19,12 @@ import java.util.LinkedHashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
-
 import net.helenus.core.*;
 import net.helenus.mapping.HelenusProperty;
 
-public abstract class AbstractFilterStreamOperation<E, O extends AbstractFilterStreamOperation<E, O>>
-		extends
-			AbstractStreamOperation<E, O> {
+public abstract class AbstractFilterStreamOperation<
+        E, O extends AbstractFilterStreamOperation<E, O>>
+    extends AbstractStreamOperation<E, O> {
 
   protected Map<HelenusProperty, Filter<?>> filters = null;
   protected List<Filter<?>> ifFilters = null;

src/main/java/net/helenus/core/operation/AbstractOperation.java

@@ -15,17 +15,16 @@
  */
 package net.helenus.core.operation;
 
+import com.codahale.metrics.Timer;
+import com.datastax.driver.core.ResultSet;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
 import java.util.concurrent.TimeoutException;
-
-import com.codahale.metrics.Timer;
-import com.datastax.driver.core.ResultSet;
-
 import net.helenus.core.AbstractSessionOperations;
 import net.helenus.core.UnitOfWork;
 
-public abstract class AbstractOperation<E, O extends AbstractOperation<E, O>> extends AbstractStatementOperation<E, O> {
+public abstract class AbstractOperation<E, O extends AbstractOperation<E, O>>
+    extends AbstractStatementOperation<E, O> {
 
   public AbstractOperation(AbstractSessionOperations sessionOperations) {
     super(sessionOperations);
@@ -40,8 +39,15 @@ public abstract class AbstractOperation<E, O extends AbstractOperation<E, O>> ex
   public E sync() throws TimeoutException {
     final Timer.Context context = requestLatency.time();
     try {
-			ResultSet resultSet = this.execute(sessionOps, null, traceContext, queryExecutionTimeout, queryTimeoutUnits,
-					showValues, false);
+      ResultSet resultSet =
+          this.execute(
+              sessionOps,
+              null,
+              traceContext,
+              queryExecutionTimeout,
+              queryTimeoutUnits,
+              showValues,
+              false);
       return transform(resultSet);
     } finally {
       context.stop();
@@ -49,13 +55,19 @@ public abstract class AbstractOperation<E, O extends AbstractOperation<E, O>> ex
   }
 
   public E sync(UnitOfWork uow) throws TimeoutException {
-		if (uow == null)
-			return sync();
+    if (uow == null) return sync();
 
     final Timer.Context context = requestLatency.time();
     try {
-			ResultSet resultSet = execute(sessionOps, uow, traceContext, queryExecutionTimeout, queryTimeoutUnits,
-					showValues, true);
+      ResultSet resultSet =
+          execute(
+              sessionOps,
+              uow,
+              traceContext,
+              queryExecutionTimeout,
+              queryTimeoutUnits,
+              showValues,
+              true);
       E result = transform(resultSet);
       return result;
     } finally {
@@ -64,7 +76,8 @@ public abstract class AbstractOperation<E, O extends AbstractOperation<E, O>> ex
   }
 
   public CompletableFuture<E> async() {
-		return CompletableFuture.<E>supplyAsync(() -> {
+    return CompletableFuture.<E>supplyAsync(
+        () -> {
           try {
             return sync();
           } catch (TimeoutException ex) {
@@ -74,9 +87,9 @@ public abstract class AbstractOperation<E, O extends AbstractOperation<E, O>> ex
   }
 
   public CompletableFuture<E> async(UnitOfWork uow) {
-		if (uow == null)
-			return async();
-		return CompletableFuture.<E>supplyAsync(() -> {
+    if (uow == null) return async();
+    return CompletableFuture.<E>supplyAsync(
+        () -> {
           try {
             return sync();
           } catch (TimeoutException ex) {

src/main/java/net/helenus/core/operation/AbstractOptionalOperation.java

@@ -17,12 +17,6 @@ package net.helenus.core.operation;
 
 import static net.helenus.core.HelenusSession.deleted;
 
-import java.util.List;
-import java.util.Optional;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionException;
-import java.util.concurrent.TimeoutException;
-
 import com.codahale.metrics.Timer;
 import com.datastax.driver.core.PreparedStatement;
 import com.datastax.driver.core.ResultSet;
@@ -30,15 +24,18 @@ import com.google.common.base.Function;
 import com.google.common.base.Stopwatch;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
-
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.TimeoutException;
 import net.helenus.core.AbstractSessionOperations;
 import net.helenus.core.UnitOfWork;
 import net.helenus.core.cache.CacheUtil;
 import net.helenus.core.cache.Facet;
 
 public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOperation<E, O>>
-		extends
-			AbstractStatementOperation<E, O> {
+    extends AbstractStatementOperation<E, O> {
 
   public AbstractOptionalOperation(AbstractSessionOperations sessionOperations) {
     super(sessionOperations);
@@ -52,7 +49,8 @@ public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOpe
 
   public ListenableFuture<PreparedOptionalOperation<E>> prepareAsync() {
     final O _this = (O) this;
-		return Futures.transform(prepareStatementAsync(),
+    return Futures.transform(
+        prepareStatementAsync(),
         new Function<PreparedStatement, PreparedOptionalOperation<E>>() {
           @Override
           public PreparedOptionalOperation<E> apply(PreparedStatement preparedStatement) {
@@ -85,8 +83,15 @@ public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOpe
 
       if (!result.isPresent()) {
         // Formulate the query and execute it against the Cassandra cluster.
-				ResultSet resultSet = this.execute(sessionOps, null, traceContext, queryExecutionTimeout,
-						queryTimeoutUnits, showValues, false);
+        ResultSet resultSet =
+            this.execute(
+                sessionOps,
+                null,
+                traceContext,
+                queryExecutionTimeout,
+                queryTimeoutUnits,
+                showValues,
+                false);
 
         // Transform the query result set into the desired shape.
         result = transform(resultSet);
@@ -105,8 +110,7 @@ public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOpe
   }
 
   public Optional<E> sync(UnitOfWork<?> uow) throws TimeoutException {
-		if (uow == null)
-			return sync();
+    if (uow == null) return sync();
 
     final Timer.Context context = requestLatency.time();
     try {
@@ -166,8 +170,15 @@ public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOpe
       } else {
 
         // Formulate the query and execute it against the Cassandra cluster.
-				ResultSet resultSet = execute(sessionOps, uow, traceContext, queryExecutionTimeout, queryTimeoutUnits,
-						showValues, true);
+        ResultSet resultSet =
+            execute(
+                sessionOps,
+                uow,
+                traceContext,
+                queryExecutionTimeout,
+                queryTimeoutUnits,
+                showValues,
+                true);
 
         // Transform the query result set into the desired shape.
         result = transform(resultSet);
@@ -186,7 +197,8 @@ public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOpe
   }
 
   public CompletableFuture<Optional<E>> async() {
-		return CompletableFuture.<Optional<E>>supplyAsync(() -> {
+    return CompletableFuture.<Optional<E>>supplyAsync(
+        () -> {
           try {
             return sync();
           } catch (TimeoutException ex) {
@@ -196,9 +208,9 @@ public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOpe
   }
 
   public CompletableFuture<Optional<E>> async(UnitOfWork<?> uow) {
-		if (uow == null)
-			return async();
-		return CompletableFuture.<Optional<E>>supplyAsync(() -> {
+    if (uow == null) return async();
+    return CompletableFuture.<Optional<E>>supplyAsync(
+        () -> {
           try {
             return sync();
           } catch (TimeoutException ex) {

src/main/java/net/helenus/core/operation/AbstractStatementOperation.java

@@ -15,12 +15,8 @@
  */
 package net.helenus.core.operation;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.TimeUnit;
-
+import brave.Tracer;
+import brave.propagation.TraceContext;
 import com.datastax.driver.core.ConsistencyLevel;
 import com.datastax.driver.core.PreparedStatement;
 import com.datastax.driver.core.RegularStatement;
@@ -31,9 +27,11 @@ import com.datastax.driver.core.policies.FallthroughRetryPolicy;
 import com.datastax.driver.core.policies.RetryPolicy;
 import com.datastax.driver.core.querybuilder.BuiltStatement;
 import com.google.common.util.concurrent.ListenableFuture;
-
-import brave.Tracer;
-import brave.propagation.TraceContext;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
 import net.helenus.core.AbstractSessionOperations;
 import net.helenus.core.UnitOfWork;
 import net.helenus.core.cache.Facet;
@@ -43,7 +41,8 @@ import net.helenus.mapping.HelenusProperty;
 import net.helenus.mapping.value.BeanColumnValueProvider;
 import net.helenus.support.HelenusException;
 
-public abstract class AbstractStatementOperation<E, O extends AbstractStatementOperation<E, O>> extends Operation<E> {
+public abstract class AbstractStatementOperation<E, O extends AbstractStatementOperation<E, O>>
+    extends Operation<E> {
 
   protected boolean checkCache = true;
   protected boolean showValues = true;
@@ -277,8 +276,7 @@ public abstract class AbstractStatementOperation<E, O extends AbstractStatementO
 
   public String cql() {
     Statement statement = buildStatement(false);
-		if (statement == null)
-			return "";
+    if (statement == null) return "";
     if (statement instanceof BuiltStatement) {
       BuiltStatement buildStatement = (BuiltStatement) statement;
       return buildStatement.setForceNoValues(true).getQueryString();
@@ -331,7 +329,8 @@ public abstract class AbstractStatementOperation<E, O extends AbstractStatementO
 
   protected void cacheUpdate(UnitOfWork<?> uow, E pojo, List<Facet> identifyingFacets) {
     List<Facet> facets = new ArrayList<>();
-		Map<String, Object> valueMap = pojo instanceof MapExportable ? ((MapExportable) pojo).toMap() : null;
+    Map<String, Object> valueMap =
+        pojo instanceof MapExportable ? ((MapExportable) pojo).toMap() : null;
 
     for (Facet facet : identifyingFacets) {
       if (facet instanceof UnboundFacet) {

src/main/java/net/helenus/core/operation/AbstractStreamOperation.java

@@ -17,13 +17,6 @@ package net.helenus.core.operation;
 
 import static net.helenus.core.HelenusSession.deleted;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionException;
-import java.util.concurrent.TimeoutException;
-import java.util.stream.Stream;
-
 import com.codahale.metrics.Timer;
 import com.datastax.driver.core.PreparedStatement;
 import com.datastax.driver.core.ResultSet;
@@ -31,15 +24,19 @@ import com.google.common.base.Function;
 import com.google.common.base.Stopwatch;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
-
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.Stream;
 import net.helenus.core.AbstractSessionOperations;
 import net.helenus.core.UnitOfWork;
 import net.helenus.core.cache.CacheUtil;
 import net.helenus.core.cache.Facet;
 
 public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperation<E, O>>
-		extends
-			AbstractStatementOperation<E, O> {
+    extends AbstractStatementOperation<E, O> {
 
   public AbstractStreamOperation(AbstractSessionOperations sessionOperations) {
     super(sessionOperations);
@@ -53,7 +50,8 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
 
   public ListenableFuture<PreparedStreamOperation<E>> prepareAsync() {
     final O _this = (O) this;
-		return Futures.transform(prepareStatementAsync(),
+    return Futures.transform(
+        prepareStatementAsync(),
         new Function<PreparedStatement, PreparedStreamOperation<E>>() {
           @Override
           public PreparedStreamOperation<E> apply(PreparedStatement preparedStatement) {
@@ -86,8 +84,15 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
 
       if (resultStream == null) {
         // Formulate the query and execute it against the Cassandra cluster.
-				ResultSet resultSet = this.execute(sessionOps, null, traceContext, queryExecutionTimeout,
-						queryTimeoutUnits, showValues, false);
+        ResultSet resultSet =
+            this.execute(
+                sessionOps,
+                null,
+                traceContext,
+                queryExecutionTimeout,
+                queryTimeoutUnits,
+                showValues,
+                false);
 
         // Transform the query result set into the desired shape.
         resultStream = transform(resultSet);
@@ -97,7 +102,8 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
         List<Facet> facets = getFacets();
         if (facets != null && facets.size() > 1) {
           List<E> again = new ArrayList<>();
-					resultStream.forEach(result -> {
+          resultStream.forEach(
+              result -> {
                 sessionOps.updateCache(result, facets);
                 again.add(result);
               });
@@ -112,8 +118,7 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
   }
 
   public Stream<E> sync(UnitOfWork uow) throws TimeoutException {
-		if (uow == null)
-			return sync();
+    if (uow == null) return sync();
 
     final Timer.Context context = requestLatency.time();
     try {
@@ -164,8 +169,15 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
 
       // Check to see if we fetched the object from the cache
       if (resultStream == null) {
-				ResultSet resultSet = execute(sessionOps, uow, traceContext, queryExecutionTimeout, queryTimeoutUnits,
-						showValues, true);
+        ResultSet resultSet =
+            execute(
+                sessionOps,
+                uow,
+                traceContext,
+                queryExecutionTimeout,
+                queryTimeoutUnits,
+                showValues,
+                true);
         resultStream = transform(resultSet);
       }
 
@@ -174,7 +186,8 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
       if (resultStream != null) {
         List<E> again = new ArrayList<>();
         List<Facet> facets = getFacets();
-				resultStream.forEach(result -> {
+        resultStream.forEach(
+            result -> {
               if (result != deleted) {
                 if (updateCache) {
                   cacheUpdate(uow, result, facets);
@@ -192,7 +205,8 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
   }
 
   public CompletableFuture<Stream<E>> async() {
-		return CompletableFuture.<Stream<E>>supplyAsync(() -> {
+    return CompletableFuture.<Stream<E>>supplyAsync(
+        () -> {
           try {
             return sync();
           } catch (TimeoutException ex) {
@@ -202,9 +216,9 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
   }
 
   public CompletableFuture<Stream<E>> async(UnitOfWork uow) {
-		if (uow == null)
-			return async();
-		return CompletableFuture.<Stream<E>>supplyAsync(() -> {
+    if (uow == null) return async();
+    return CompletableFuture.<Stream<E>>supplyAsync(
+        () -> {
           try {
             return sync();
           } catch (TimeoutException ex) {

src/main/java/net/helenus/core/operation/BoundOptionalOperation.java

@@ -15,18 +15,19 @@
  */
 package net.helenus.core.operation;
 
-import java.util.Optional;
-
 import com.datastax.driver.core.BoundStatement;
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Statement;
+import java.util.Optional;
 
-public final class BoundOptionalOperation<E> extends AbstractOptionalOperation<E, BoundOptionalOperation<E>> {
+public final class BoundOptionalOperation<E>
+    extends AbstractOptionalOperation<E, BoundOptionalOperation<E>> {
 
   private final BoundStatement boundStatement;
   private final AbstractOptionalOperation<E, ?> delegate;
 
-	public BoundOptionalOperation(BoundStatement boundStatement, AbstractOptionalOperation<E, ?> operation) {
+  public BoundOptionalOperation(
+      BoundStatement boundStatement, AbstractOptionalOperation<E, ?> operation) {
     super(operation.sessionOps);
     this.boundStatement = boundStatement;
     this.delegate = operation;

src/main/java/net/helenus/core/operation/BoundStreamOperation.java

@@ -15,21 +15,21 @@
  */
 package net.helenus.core.operation;
 
-import java.util.List;
-import java.util.stream.Stream;
-
 import com.datastax.driver.core.BoundStatement;
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Statement;
-
+import java.util.List;
+import java.util.stream.Stream;
 import net.helenus.core.cache.Facet;
 
-public final class BoundStreamOperation<E> extends AbstractStreamOperation<E, BoundStreamOperation<E>> {
+public final class BoundStreamOperation<E>
+    extends AbstractStreamOperation<E, BoundStreamOperation<E>> {
 
   private final BoundStatement boundStatement;
   private final AbstractStreamOperation<E, ?> delegate;
 
-	public BoundStreamOperation(BoundStatement boundStatement, AbstractStreamOperation<E, ?> operation) {
+  public BoundStreamOperation(
+      BoundStatement boundStatement, AbstractStreamOperation<E, ?> operation) {
     super(operation.sessionOps);
     this.boundStatement = boundStatement;
     this.delegate = operation;

src/main/java/net/helenus/core/operation/CountOperation.java

@@ -20,7 +20,6 @@ import com.datastax.driver.core.querybuilder.BuiltStatement;
 import com.datastax.driver.core.querybuilder.QueryBuilder;
 import com.datastax.driver.core.querybuilder.Select;
 import com.datastax.driver.core.querybuilder.Select.Where;
-
 import net.helenus.core.AbstractSessionOperations;
 import net.helenus.core.Filter;
 import net.helenus.core.reflect.HelenusPropertyNode;
@@ -74,8 +73,11 @@ public final class CountOperation extends AbstractFilterOperation<Long, CountOpe
     if (entity == null) {
       entity = p.getEntity();
     } else if (entity != p.getEntity()) {
-			throw new HelenusMappingException("you can count columns only in single entity "
-					+ entity.getMappingInterface() + " or " + p.getEntity().getMappingInterface());
+      throw new HelenusMappingException(
+          "you can count columns only in single entity "
+              + entity.getMappingInterface()
+              + " or "
+              + p.getEntity().getMappingInterface());
     }
   }
 }

src/main/java/net/helenus/core/operation/DeleteOperation.java

@@ -15,15 +15,13 @@
  */
 package net.helenus.core.operation;
 
-import java.util.List;
-import java.util.concurrent.TimeoutException;
-
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.querybuilder.BuiltStatement;
 import com.datastax.driver.core.querybuilder.Delete;
 import com.datastax.driver.core.querybuilder.Delete.Where;
 import com.datastax.driver.core.querybuilder.QueryBuilder;
-
+import java.util.List;
+import java.util.concurrent.TimeoutException;
 import net.helenus.core.AbstractSessionOperations;
 import net.helenus.core.Filter;
 import net.helenus.core.UnitOfWork;
@@ -123,8 +121,11 @@ public final class DeleteOperation extends AbstractFilterOperation<ResultSet, De
     if (entity == null) {
       entity = p.getEntity();
     } else if (entity != p.getEntity()) {
-			throw new HelenusMappingException("you can delete rows only in single entity "
-					+ entity.getMappingInterface() + " or " + p.getEntity().getMappingInterface());
+      throw new HelenusMappingException(
+          "you can delete rows only in single entity "
+              + entity.getMappingInterface()
+              + " or "
+              + p.getEntity().getMappingInterface());
     }
   }
 
@@ -155,5 +156,4 @@ public final class DeleteOperation extends AbstractFilterOperation<ResultSet, De
   public List<Facet> getFacets() {
     return entity.getFacets();
   }
-
 }

src/main/java/net/helenus/core/operation/InsertOperation.java

@@ -15,15 +15,13 @@
  */
 package net.helenus.core.operation;
 
-import java.util.*;
-import java.util.concurrent.TimeoutException;
-import java.util.function.Function;
-
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.querybuilder.BuiltStatement;
 import com.datastax.driver.core.querybuilder.Insert;
 import com.datastax.driver.core.querybuilder.QueryBuilder;
-
+import java.util.*;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Function;
 import net.helenus.core.AbstractSessionOperations;
 import net.helenus.core.Getter;
 import net.helenus.core.Helenus;
@@ -43,7 +41,8 @@ import net.helenus.support.HelenusMappingException;
 
 public final class InsertOperation<T> extends AbstractOperation<T, InsertOperation<T>> {
 
-	private final List<Fun.Tuple2<HelenusPropertyNode, Object>> values = new ArrayList<Fun.Tuple2<HelenusPropertyNode, Object>>();
+  private final List<Fun.Tuple2<HelenusPropertyNode, Object>> values =
+      new ArrayList<Fun.Tuple2<HelenusPropertyNode, Object>>();
   private final T pojo;
   private final Class<?> resultType;
   private HelenusEntity entity;
@@ -60,7 +59,8 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
     this.resultType = ResultSet.class;
   }
 
-	public InsertOperation(AbstractSessionOperations sessionOperations, Class<?> resultType, boolean ifNotExists) {
+  public InsertOperation(
+      AbstractSessionOperations sessionOperations, Class<?> resultType, boolean ifNotExists) {
     super(sessionOperations);
 
     this.ifNotExists = ifNotExists;
@@ -68,8 +68,12 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
     this.resultType = resultType;
   }
 
-	public InsertOperation(AbstractSessionOperations sessionOperations, HelenusEntity entity, T pojo,
-			Set<String> mutations, boolean ifNotExists) {
+  public InsertOperation(
+      AbstractSessionOperations sessionOperations,
+      HelenusEntity entity,
+      T pojo,
+      Set<String> mutations,
+      boolean ifNotExists) {
     super(sessionOperations);
 
     this.entity = entity;
@@ -84,11 +88,11 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
       boolean addProp = false;
 
       switch (prop.getColumnType()) {
-				case PARTITION_KEY :
-				case CLUSTERING_COLUMN :
+        case PARTITION_KEY:
+        case CLUSTERING_COLUMN:
           addProp = true;
           break;
-				default :
+        default:
           addProp = (keys == null || keys.contains(prop.getPropertyName()));
       }
 
@@ -135,8 +139,7 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
 
     values.forEach(t -> addPropertyNode(t._1));
 
-		if (values.isEmpty())
-			return null;
+    if (values.isEmpty()) return null;
 
     if (entity == null) {
       throw new HelenusMappingException("unknown entity");
@@ -148,7 +151,8 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
       insert.ifNotExists();
     }
 
-		values.forEach(t -> {
+    values.forEach(
+        t -> {
           insert.value(t._1.getColumnName(), t._2);
         });
 
@@ -184,8 +188,8 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
           if (backingMap.containsKey(key)) {
             // Some values man need to be converted (e.g. from String to Enum). This is done
             // within the BeanColumnValueProvider below.
-						Optional<Function<Object, Object>> converter = prop
-								.getReadConverter(sessionOps.getSessionRepository());
+            Optional<Function<Object, Object>> converter =
+                prop.getReadConverter(sessionOps.getSessionRepository());
             if (converter.isPresent()) {
               backingMap.put(key, converter.get().apply(backingMap.get(key)));
             }
@@ -193,8 +197,8 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
             // If we started this operation with an instance of this type, use values from
             // that.
             if (pojo != null) {
-							backingMap.put(key,
-									BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop, immutable));
+              backingMap.put(
+                  key, BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop, immutable));
             } else {
               // Otherwise we'll use default values for the property type if available.
               Class<?> propType = prop.getJavaType();
@@ -234,8 +238,11 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
     if (entity == null) {
       entity = p.getEntity();
     } else if (entity != p.getEntity()) {
-			throw new HelenusMappingException("you can insert only single entity " + entity.getMappingInterface()
-					+ " or " + p.getEntity().getMappingInterface());
+      throw new HelenusMappingException(
+          "you can insert only single entity "
+              + entity.getMappingInterface()
+              + " or "
+              + p.getEntity().getMappingInterface());
     }
   }
 
@@ -312,5 +319,4 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
       return new ArrayList<Facet>();
     }
   }
-
 }

src/main/java/net/helenus/core/operation/Operation.java

@@ -15,30 +15,27 @@
  */
 package net.helenus.core.operation;
 
-import java.net.InetAddress;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.stream.Collectors;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
+import brave.Span;
+import brave.Tracer;
+import brave.propagation.TraceContext;
 import com.codahale.metrics.Meter;
 import com.codahale.metrics.MetricRegistry;
 import com.codahale.metrics.Timer;
 import com.datastax.driver.core.*;
 import com.datastax.driver.core.querybuilder.BuiltStatement;
 import com.google.common.base.Stopwatch;
-
-import brave.Span;
-import brave.Tracer;
-import brave.propagation.TraceContext;
+import java.net.InetAddress;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.stream.Collectors;
 import net.helenus.core.AbstractSessionOperations;
 import net.helenus.core.UnitOfWork;
 import net.helenus.core.cache.Facet;
 import net.helenus.support.HelenusException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public abstract class Operation<E> {
 
@@ -83,13 +80,19 @@ public abstract class Operation<E> {
       query = regularStatement.getQueryString();
     } else {
       query = statement.toString();
-
     }
     return query;
   }
 
-	public ResultSet execute(AbstractSessionOperations session, UnitOfWork uow, TraceContext traceContext, long timeout,
-			TimeUnit units, boolean showValues, boolean cached) throws TimeoutException {
+  public ResultSet execute(
+      AbstractSessionOperations session,
+      UnitOfWork uow,
+      TraceContext traceContext,
+      long timeout,
+      TimeUnit units,
+      boolean showValues,
+      boolean cached)
+      throws TimeoutException {
 
     // Start recording in a Zipkin sub-span our execution time to perform this
     // operation.
@@ -110,31 +113,39 @@ public abstract class Operation<E> {
       Stopwatch timer = Stopwatch.createStarted();
       try {
         ResultSetFuture futureResultSet = session.executeAsync(statement, uow, timer, showValues);
-				if (uow != null)
-					uow.recordCacheAndDatabaseOperationCount(0, 1);
+        if (uow != null) uow.recordCacheAndDatabaseOperationCount(0, 1);
         ResultSet resultSet = futureResultSet.getUninterruptibly(timeout, units);
         ColumnDefinitions columnDefinitions = resultSet.getColumnDefinitions();
         if (LOG.isDebugEnabled()) {
           ExecutionInfo ei = resultSet.getExecutionInfo();
           Host qh = ei.getQueriedHost();
-					String oh = ei.getTriedHosts().stream().map(Host::getAddress).map(InetAddress::toString)
+          String oh =
+              ei.getTriedHosts()
+                  .stream()
+                  .map(Host::getAddress)
+                  .map(InetAddress::toString)
                   .collect(Collectors.joining(", "));
           ConsistencyLevel cl = ei.getAchievedConsistencyLevel();
           int se = ei.getSpeculativeExecutions();
           String warn = ei.getWarnings().stream().collect(Collectors.joining(", "));
-					String ri = String.format("%s %s %s %s %s %s%sspec-retries: %d",
-							"server v" + qh.getCassandraVersion(), qh.getAddress().toString(),
-							(oh != null && !oh.equals("")) ? " [tried: " + oh + "]" : "", qh.getDatacenter(),
+          String ri =
+              String.format(
+                  "%s %s %s %s %s %s%sspec-retries: %d",
+                  "server v" + qh.getCassandraVersion(),
+                  qh.getAddress().toString(),
+                  (oh != null && !oh.equals("")) ? " [tried: " + oh + "]" : "",
+                  qh.getDatacenter(),
                   qh.getRack(),
                   (cl != null)
-									? (" consistency: " + cl.name() + (cl.isDCLocal() ? " DC " : "")
+                      ? (" consistency: "
+                          + cl.name()
+                          + (cl.isDCLocal() ? " DC " : "")
                           + (cl.isSerial() ? " SC " : ""))
                       : "",
-							(warn != null && !warn.equals("")) ? ": " + warn : "", se);
-					if (uow != null)
-						uow.setInfo(ri);
-					else
-						LOG.debug(ri);
+                  (warn != null && !warn.equals("")) ? ": " + warn : "",
+                  se);
+          if (uow != null) uow.setInfo(ri);
+          else LOG.debug(ri);
         }
         if (!resultSet.wasApplied()
             && !(columnDefinitions.size() > 1 || !columnDefinitions.contains("[applied]"))) {
@@ -144,8 +155,7 @@ public abstract class Operation<E> {
 
       } finally {
         timer.stop();
-				if (uow != null)
-					uow.addDatabaseTime("Cassandra", timer);
+        if (uow != null) uow.addDatabaseTime("Cassandra", timer);
         log(statement, uow, timer, showValues);
       }
 
@@ -167,7 +177,8 @@ public abstract class Operation<E> {
       if (timer != null) {
         timerString = String.format(" %s ", timer.toString());
       }
-			LOG.info(String.format("%s%s%s", uowString, timerString, Operation.queryString(statement, false)));
+      LOG.info(
+          String.format("%s%s%s", uowString, timerString, Operation.queryString(statement, false)));
     }
   }
 
@@ -190,5 +201,4 @@ public abstract class Operation<E> {
   public boolean isSessionCacheable() {
     return false;
   }
-
 }

src/main/java/net/helenus/core/operation/PreparedOperation.java

@@ -43,5 +43,4 @@ public final class PreparedOperation<E> {
   public String toString() {
     return preparedStatement.getQueryString();
   }
-
 }

src/main/java/net/helenus/core/operation/PreparedOptionalOperation.java

@@ -23,7 +23,8 @@ public final class PreparedOptionalOperation<E> {
   private final PreparedStatement preparedStatement;
   private final AbstractOptionalOperation<E, ?> operation;
 
-	public PreparedOptionalOperation(PreparedStatement statement, AbstractOptionalOperation<E, ?> operation) {
+  public PreparedOptionalOperation(
+      PreparedStatement statement, AbstractOptionalOperation<E, ?> operation) {
     this.preparedStatement = statement;
     this.operation = operation;
   }

src/main/java/net/helenus/core/operation/PreparedStreamOperation.java

@@ -23,7 +23,8 @@ public final class PreparedStreamOperation<E> {
   private final PreparedStatement preparedStatement;
   private final AbstractStreamOperation<E, ?> operation;
 
-	public PreparedStreamOperation(PreparedStatement statement, AbstractStreamOperation<E, ?> operation) {
+  public PreparedStreamOperation(
+      PreparedStatement statement, AbstractStreamOperation<E, ?> operation) {
     this.preparedStatement = statement;
     this.operation = operation;
   }

src/main/java/net/helenus/core/operation/SelectFirstOperation.java

@@ -15,16 +15,15 @@
  */
 package net.helenus.core.operation;
 
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.querybuilder.BuiltStatement;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
-
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.querybuilder.BuiltStatement;
-
 import net.helenus.core.cache.Facet;
 
-public final class SelectFirstOperation<E> extends AbstractFilterOptionalOperation<E, SelectFirstOperation<E>> {
+public final class SelectFirstOperation<E>
+    extends AbstractFilterOptionalOperation<E, SelectFirstOperation<E>> {
 
   private final SelectOperation<E> delegate;
 

src/main/java/net/helenus/core/operation/SelectFirstTransformingOperation.java

@@ -15,18 +15,15 @@
  */
 package net.helenus.core.operation;
 
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.querybuilder.BuiltStatement;
 import java.util.List;
 import java.util.Optional;
 import java.util.function.Function;
-
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.querybuilder.BuiltStatement;
-
 import net.helenus.core.cache.Facet;
 
 public final class SelectFirstTransformingOperation<R, E>
-		extends
-			AbstractFilterOptionalOperation<R, SelectFirstTransformingOperation<R, E>> {
+    extends AbstractFilterOptionalOperation<R, SelectFirstTransformingOperation<R, E>> {
 
   private final SelectOperation<E> delegate;
   private final Function<E, R> fn;

src/main/java/net/helenus/core/operation/SelectOperation.java

@@ -15,14 +15,6 @@
  */
 package net.helenus.core.operation;
 
-import java.util.*;
-import java.util.function.Function;
-import java.util.stream.Stream;
-import java.util.stream.StreamSupport;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.Row;
 import com.datastax.driver.core.querybuilder.BuiltStatement;
@@ -32,7 +24,10 @@ import com.datastax.driver.core.querybuilder.Select;
 import com.datastax.driver.core.querybuilder.Select.Selection;
 import com.datastax.driver.core.querybuilder.Select.Where;
 import com.google.common.collect.Iterables;
-
+import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
 import net.helenus.core.*;
 import net.helenus.core.cache.Facet;
 import net.helenus.core.cache.UnboundFacet;
@@ -45,6 +40,8 @@ import net.helenus.mapping.value.ColumnValueProvider;
 import net.helenus.mapping.value.ValueProviderMap;
 import net.helenus.support.Fun;
 import net.helenus.support.HelenusMappingException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, SelectOperation<E>> {
 
@@ -62,7 +59,8 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
   public SelectOperation(AbstractSessionOperations sessionOperations) {
     super(sessionOperations);
 
-		this.rowMapper = new Function<Row, E>() {
+    this.rowMapper =
+        new Function<Row, E>() {
 
           @Override
           public E apply(Row source) {
@@ -85,25 +83,35 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
 
     super(sessionOperations);
 
-		entity.getOrderedProperties().stream().map(p -> new HelenusPropertyNode(p, Optional.empty()))
+    entity
+        .getOrderedProperties()
+        .stream()
+        .map(p -> new HelenusPropertyNode(p, Optional.empty()))
         .forEach(p -> this.props.add(p));
 
     isCacheable = entity.isCacheable();
   }
 
-	public SelectOperation(AbstractSessionOperations sessionOperations, HelenusEntity entity,
+  public SelectOperation(
+      AbstractSessionOperations sessionOperations,
+      HelenusEntity entity,
       Function<Row, E> rowMapper) {
 
     super(sessionOperations);
     this.rowMapper = rowMapper;
 
-		entity.getOrderedProperties().stream().map(p -> new HelenusPropertyNode(p, Optional.empty()))
+    entity
+        .getOrderedProperties()
+        .stream()
+        .map(p -> new HelenusPropertyNode(p, Optional.empty()))
         .forEach(p -> this.props.add(p));
 
     isCacheable = entity.isCacheable();
   }
 
-	public SelectOperation(AbstractSessionOperations sessionOperations, Function<Row, E> rowMapper,
+  public SelectOperation(
+      AbstractSessionOperations sessionOperations,
+      Function<Row, E> rowMapper,
       HelenusPropertyNode... props) {
 
     super(sessionOperations);
@@ -120,8 +128,11 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
       if (entity == null) {
         entity = prop.getEntity();
       } else if (entity != prop.getEntity()) {
-				throw new HelenusMappingException("you can count records only from a single entity "
-						+ entity.getMappingInterface() + " or " + prop.getEntity().getMappingInterface());
+        throw new HelenusMappingException(
+            "you can count records only from a single entity "
+                + entity.getMappingInterface()
+                + " or "
+                + prop.getEntity().getMappingInterface());
       }
     }
 
@@ -133,7 +144,10 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
     HelenusEntity entity = Helenus.entity(materializedViewClass);
     this.alternateTableName = entity.getName().toCql();
     this.props.clear();
-		entity.getOrderedProperties().stream().map(p -> new HelenusPropertyNode(p, Optional.empty()))
+    entity
+        .getOrderedProperties()
+        .stream()
+        .map(p -> new HelenusPropertyNode(p, Optional.empty()))
         .forEach(p -> this.props.add(p));
     return this;
   }
@@ -151,7 +165,9 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
 
     this.rowMapper = null;
 
-		return new SelectTransformingOperation<R, E>(this, (r) -> {
+    return new SelectTransformingOperation<R, E>(
+        this,
+        (r) -> {
           Map<String, Object> map = new ValueProviderMap(r, sessionOps.getValueProvider(), entity);
           return (R) Helenus.map(entityClass, map);
         });
@@ -217,7 +233,6 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
               }
             }
           }
-
         }
         if (binder.isBound()) {
           boundFacets.add(binder.bind());
@@ -242,18 +257,21 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
       if (entity == null) {
         entity = prop.getEntity();
       } else if (entity != prop.getEntity()) {
-				throw new HelenusMappingException("you can select columns only from a single entity "
-						+ entity.getMappingInterface() + " or " + prop.getEntity().getMappingInterface());
+        throw new HelenusMappingException(
+            "you can select columns only from a single entity "
+                + entity.getMappingInterface()
+                + " or "
+                + prop.getEntity().getMappingInterface());
       }
 
       // TODO(gburd): writeTime and ttl will be useful on merge() but cause object
       // identity to fail.
       if (false && cached) {
         switch (prop.getProperty().getColumnType()) {
-					case PARTITION_KEY :
-					case CLUSTERING_COLUMN :
+          case PARTITION_KEY:
+          case CLUSTERING_COLUMN:
             break;
-					default :
+          default:
             if (entity.equals(prop.getEntity())) {
               if (prop.getNext().isPresent()) {
                 columnName = Iterables.getLast(prop).getColumnName().toCql(true);
@@ -293,10 +311,10 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
         HelenusProperty prop = filter.getNode().getProperty();
         if (allowFiltering == false) {
           switch (prop.getColumnType()) {
-						case PARTITION_KEY :
-						case CLUSTERING_COLUMN :
+            case PARTITION_KEY:
+            case CLUSTERING_COLUMN:
               break;
-						default :
+            default:
               // When using non-Cassandra-standard 2i types or when using more than one
               // indexed column or non-indexed columns the query must include ALLOW FILTERING.
               if (prop.caseSensitiveIndex()) {
@@ -327,12 +345,14 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
   @Override
   public Stream<E> transform(ResultSet resultSet) {
     if (rowMapper != null) {
-			return StreamSupport
-					.stream(Spliterators.spliteratorUnknownSize(resultSet.iterator(), Spliterator.ORDERED), false)
+      return StreamSupport.stream(
+              Spliterators.spliteratorUnknownSize(resultSet.iterator(), Spliterator.ORDERED), false)
           .map(rowMapper);
     } else {
-			return (Stream<E>) StreamSupport
-					.stream(Spliterators.spliteratorUnknownSize(resultSet.iterator(), Spliterator.ORDERED), false);
+      return (Stream<E>)
+          StreamSupport.stream(
+              Spliterators.spliteratorUnknownSize(resultSet.iterator(), Spliterator.ORDERED),
+              false);
     }
   }
 

src/main/java/net/helenus/core/operation/SelectTransformingOperation.java

@@ -15,18 +15,15 @@
  */
 package net.helenus.core.operation;
 
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.querybuilder.BuiltStatement;
 import java.util.List;
 import java.util.function.Function;
 import java.util.stream.Stream;
-
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.querybuilder.BuiltStatement;
-
 import net.helenus.core.cache.Facet;
 
 public final class SelectTransformingOperation<R, E>
-		extends
-			AbstractFilterStreamOperation<R, SelectTransformingOperation<R, E>> {
+    extends AbstractFilterStreamOperation<R, SelectTransformingOperation<R, E>> {
 
   private final SelectOperation<E> delegate;
   private final Function<E, R> fn;

src/main/java/net/helenus/core/operation/UpdateOperation.java

@@ -15,17 +15,15 @@
  */
 package net.helenus.core.operation;
 
-import java.util.*;
-import java.util.concurrent.TimeoutException;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
 import com.datastax.driver.core.ResultSet;
 import com.datastax.driver.core.querybuilder.Assignment;
 import com.datastax.driver.core.querybuilder.BuiltStatement;
 import com.datastax.driver.core.querybuilder.QueryBuilder;
 import com.datastax.driver.core.querybuilder.Update;
-
+import java.util.*;
+import java.util.concurrent.TimeoutException;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 import net.helenus.core.*;
 import net.helenus.core.cache.BoundFacet;
 import net.helenus.core.cache.Facet;
@@ -56,7 +54,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     this.draftMap = null;
   }
 
-	public UpdateOperation(AbstractSessionOperations sessionOperations, AbstractEntityDraft<E> draft) {
+  public UpdateOperation(
+      AbstractSessionOperations sessionOperations, AbstractEntityDraft<E> draft) {
     super(sessionOperations);
     this.draft = draft;
     this.draftMap = draft.toMap();
@@ -70,7 +69,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     this.entity = Helenus.resolve(MappingUtil.getMappingInterface(pojo));
   }
 
-	public UpdateOperation(AbstractSessionOperations sessionOperations, HelenusPropertyNode p, Object v) {
+  public UpdateOperation(
+      AbstractSessionOperations sessionOperations, HelenusPropertyNode p, Object v) {
     super(sessionOperations);
     this.draft = null;
     this.draftMap = null;
@@ -194,7 +194,9 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			List<V> list = new ArrayList<V>((List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      List<V> list =
+          new ArrayList<V>(
+              (List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       list.add(0, value);
       facet = new BoundFacet(prop, list);
     } else if (draft != null) {
@@ -221,7 +223,9 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			List<V> list = new ArrayList<V>((List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      List<V> list =
+          new ArrayList<V>(
+              (List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       list.addAll(0, value);
       facet = new BoundFacet(prop, list);
     } else if (draft != null && value.size() > 0) {
@@ -250,7 +254,9 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
       List<V> list;
       HelenusProperty prop = p.getProperty();
       if (pojo != null) {
-				list = new ArrayList<V>((List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+        list =
+            new ArrayList<V>(
+                (List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       } else {
         String key = p.getProperty().getPropertyName();
         list = (List<V>) draftMap.get(key);
@@ -284,7 +290,9 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			List<V> list = new ArrayList<V>((List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      List<V> list =
+          new ArrayList<V>(
+              (List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       list.add(value);
       facet = new BoundFacet(prop, list);
     } else if (draft != null) {
@@ -310,7 +318,9 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			List<V> list = new ArrayList<V>((List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      List<V> list =
+          new ArrayList<V>(
+              (List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       list.addAll(value);
       facet = new BoundFacet(prop, list);
     } else if (draft != null && value.size() > 0) {
@@ -336,7 +346,9 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			List<V> list = new ArrayList<V>((List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      List<V> list =
+          new ArrayList<V>(
+              (List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       list.remove(value);
       facet = new BoundFacet(prop, list);
     } else if (draft != null) {
@@ -362,7 +374,9 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			List<V> list = new ArrayList<V>((List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      List<V> list =
+          new ArrayList<V>(
+              (List<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       list.removeAll(value);
       facet = new BoundFacet(prop, list);
     } else if (draft != null) {
@@ -382,7 +396,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
 
     Object valueObj = value;
 
-		Optional<Function<Object, Object>> converter = prop.getWriteConverter(sessionOps.getSessionRepository());
+    Optional<Function<Object, Object>> converter =
+        prop.getWriteConverter(sessionOps.getSessionRepository());
     if (converter.isPresent()) {
       List convertedList = (List) converter.get().apply(Immutables.listOf(value));
       valueObj = convertedList.get(0);
@@ -397,7 +412,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
 
     List valueObj = value;
 
-		Optional<Function<Object, Object>> converter = prop.getWriteConverter(sessionOps.getSessionRepository());
+    Optional<Function<Object, Object>> converter =
+        prop.getWriteConverter(sessionOps.getSessionRepository());
     if (converter.isPresent()) {
       valueObj = (List) converter.get().apply(value);
     }
@@ -424,7 +440,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			Set<V> set = new HashSet<V>((Set<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      Set<V> set =
+          new HashSet<V>((Set<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       set.add(value);
       facet = new BoundFacet(prop, set);
     } else if (draft != null) {
@@ -450,7 +467,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			Set<V> set = new HashSet<V>((Set<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      Set<V> set =
+          new HashSet<V>((Set<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       set.addAll(value);
       facet = new BoundFacet(prop, set);
     } else if (draft != null) {
@@ -476,7 +494,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			Set<V> set = new HashSet<V>((Set<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      Set<V> set =
+          new HashSet<V>((Set<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       set.remove(value);
       facet = new BoundFacet(prop, set);
     } else if (draft != null) {
@@ -502,7 +521,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     BoundFacet facet = null;
     if (pojo != null) {
       HelenusProperty prop = p.getProperty();
-			Set<V> set = new HashSet<V>((Set<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
+      Set<V> set =
+          new HashSet<V>((Set<V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       set.removeAll(value);
       facet = new BoundFacet(prop, set);
     } else if (draft != null) {
@@ -522,7 +542,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     HelenusProperty prop = p.getProperty();
     Object valueObj = value;
 
-		Optional<Function<Object, Object>> converter = prop.getWriteConverter(sessionOps.getSessionRepository());
+    Optional<Function<Object, Object>> converter =
+        prop.getWriteConverter(sessionOps.getSessionRepository());
     if (converter.isPresent()) {
       Set convertedSet = (Set) converter.get().apply(Immutables.setOf(value));
       valueObj = convertedSet.iterator().next();
@@ -536,7 +557,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     HelenusProperty prop = p.getProperty();
     Set valueObj = value;
 
-		Optional<Function<Object, Object>> converter = prop.getWriteConverter(sessionOps.getSessionRepository());
+    Optional<Function<Object, Object>> converter =
+        prop.getWriteConverter(sessionOps.getSessionRepository());
     if (converter.isPresent()) {
       valueObj = (Set) converter.get().apply(value);
     }
@@ -562,7 +584,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
 
     BoundFacet facet = null;
     if (pojo != null) {
-			Map<K, V> map = new HashMap<K, V>(
+      Map<K, V> map =
+          new HashMap<K, V>(
               (Map<K, V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       map.put(key, value);
       facet = new BoundFacet(prop, map);
@@ -570,10 +593,11 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
       ((Map<K, V>) draftMap.get(prop.getPropertyName())).put(key, value);
     }
 
-		Optional<Function<Object, Object>> converter = prop.getWriteConverter(sessionOps.getSessionRepository());
+    Optional<Function<Object, Object>> converter =
+        prop.getWriteConverter(sessionOps.getSessionRepository());
     if (converter.isPresent()) {
-			Map<Object, Object> convertedMap = (Map<Object, Object>) converter.get()
-					.apply(Immutables.mapOf(key, value));
+      Map<Object, Object> convertedMap =
+          (Map<Object, Object>) converter.get().apply(Immutables.mapOf(key, value));
       for (Map.Entry<Object, Object> e : convertedMap.entrySet()) {
         assignments.put(QueryBuilder.put(p.getColumnName(), e.getKey(), e.getValue()), facet);
       }
@@ -596,7 +620,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
 
     BoundFacet facet = null;
     if (pojo != null) {
-			Map<K, V> newMap = new HashMap<K, V>(
+      Map<K, V> newMap =
+          new HashMap<K, V>(
               (Map<K, V>) BeanColumnValueProvider.INSTANCE.getColumnValue(pojo, -1, prop));
       newMap.putAll(map);
       facet = new BoundFacet(prop, newMap);
@@ -604,7 +629,8 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
       ((Map<K, V>) draftMap.get(prop.getPropertyName())).putAll(map);
     }
 
-		Optional<Function<Object, Object>> converter = prop.getWriteConverter(sessionOps.getSessionRepository());
+    Optional<Function<Object, Object>> converter =
+        prop.getWriteConverter(sessionOps.getSessionRepository());
     if (converter.isPresent()) {
       Map convertedMap = (Map) converter.get().apply(map);
       assignments.put(QueryBuilder.putAll(p.getColumnName(), convertedMap), facet);
@@ -684,8 +710,11 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
     if (entity == null) {
       entity = p.getEntity();
     } else if (entity != p.getEntity()) {
-			throw new HelenusMappingException("you can update columns only in single entity "
-					+ entity.getMappingInterface() + " or " + p.getEntity().getMappingInterface());
+      throw new HelenusMappingException(
+          "you can update columns only in single entity "
+              + entity.getMappingInterface()
+              + " or "
+              + p.getEntity().getMappingInterface());
     }
   }
 
@@ -722,7 +751,13 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
   @Override
   public List<Facet> bindFacetValues() {
     List<Facet> facets = bindFacetValues(entity.getFacets());
-		facets.addAll(assignments.values().stream().distinct().filter(o -> o != null).collect(Collectors.toList()));
+    facets.addAll(
+        assignments
+            .values()
+            .stream()
+            .distinct()
+            .filter(o -> o != null)
+            .collect(Collectors.toList()));
     return facets;
   }
 
@@ -734,5 +769,4 @@ public final class UpdateOperation<E> extends AbstractFilterOperation<E, UpdateO
       return new ArrayList<Facet>();
     }
   }
-
 }

src/main/java/net/helenus/core/reflect/DefaultPrimitiveTypes.java

@@ -19,10 +19,17 @@ import java.util.HashMap;
 import java.util.Map;
 
 public enum DefaultPrimitiveTypes {
-	BOOLEAN(boolean.class, false), BYTE(byte.class, (byte) 0x0), CHAR(char.class, (char) 0x0), SHORT(short.class,
-			(short) 0), INT(int.class, 0), LONG(long.class, 0L), FLOAT(float.class, 0.0f), DOUBLE(double.class, 0.0);
+  BOOLEAN(boolean.class, false),
+  BYTE(byte.class, (byte) 0x0),
+  CHAR(char.class, (char) 0x0),
+  SHORT(short.class, (short) 0),
+  INT(int.class, 0),
+  LONG(long.class, 0L),
+  FLOAT(float.class, 0.0f),
+  DOUBLE(double.class, 0.0);
 
-	private static final Map<Class<?>, DefaultPrimitiveTypes> map = new HashMap<Class<?>, DefaultPrimitiveTypes>();
+  private static final Map<Class<?>, DefaultPrimitiveTypes> map =
+      new HashMap<Class<?>, DefaultPrimitiveTypes>();
 
   static {
     for (DefaultPrimitiveTypes type : DefaultPrimitiveTypes.values()) {

src/main/java/net/helenus/core/reflect/DslExportable.java

@@ -16,7 +16,6 @@
 package net.helenus.core.reflect;
 
 import com.datastax.driver.core.Metadata;
-
 import net.helenus.mapping.HelenusEntity;
 
 public interface DslExportable {

src/main/java/net/helenus/core/reflect/DslInvocationHandler.java

@@ -15,6 +15,7 @@
  */
 package net.helenus.core.reflect;
 
+import com.datastax.driver.core.*;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
@@ -22,9 +23,6 @@ import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Optional;
-
-import com.datastax.driver.core.*;
-
 import net.helenus.core.Helenus;
 import net.helenus.mapping.HelenusEntity;
 import net.helenus.mapping.HelenusMappingEntity;
@@ -46,7 +44,10 @@ public class DslInvocationHandler<E> implements InvocationHandler {
   private HelenusEntity entity = null;
   private Metadata metadata = null;
 
-	public DslInvocationHandler(Class<E> iface, ClassLoader classLoader, Optional<HelenusPropertyNode> parent,
+  public DslInvocationHandler(
+      Class<E> iface,
+      ClassLoader classLoader,
+      Optional<HelenusPropertyNode> parent,
       Metadata metadata) {
 
     this.metadata = metadata;
@@ -75,8 +76,12 @@ public class DslInvocationHandler<E> implements InvocationHandler {
 
         if (type instanceof UDTDataType && !UDTValue.class.isAssignableFrom(javaType)) {
 
-					Object childDsl = Helenus.dsl(javaType, classLoader,
-							Optional.of(new HelenusPropertyNode(prop, parent)), metadata);
+          Object childDsl =
+              Helenus.dsl(
+                  javaType,
+                  classLoader,
+                  Optional.of(new HelenusPropertyNode(prop, parent)),
+                  metadata);
 
           udtMap.put(prop.getGetterMethod(), childDsl);
         }
@@ -84,10 +89,15 @@ public class DslInvocationHandler<E> implements InvocationHandler {
         if (type instanceof DTDataType) {
           DTDataType dataType = (DTDataType) type;
 
-					if (dataType.getDataType() instanceof TupleType && !TupleValue.class.isAssignableFrom(javaType)) {
+          if (dataType.getDataType() instanceof TupleType
+              && !TupleValue.class.isAssignableFrom(javaType)) {
 
-						Object childDsl = Helenus.dsl(javaType, classLoader,
-								Optional.of(new HelenusPropertyNode(prop, parent)), metadata);
+            Object childDsl =
+                Helenus.dsl(
+                    javaType,
+                    classLoader,
+                    Optional.of(new HelenusPropertyNode(prop, parent)),
+                    metadata);
 
             tupleMap.put(prop.getGetterMethod(), childDsl);
           }
@@ -115,7 +125,9 @@ public class DslInvocationHandler<E> implements InvocationHandler {
       return false;
     }
 
-		if (DslExportable.SET_METADATA_METHOD.equals(methodName) && args.length == 1 && args[0] instanceof Metadata) {
+    if (DslExportable.SET_METADATA_METHOD.equals(methodName)
+        && args.length == 1
+        && args[0] instanceof Metadata) {
       if (metadata == null) {
         this.setCassandraMetadataForHelenusSession((Metadata) args[0]);
       }
@@ -169,7 +181,7 @@ public class DslInvocationHandler<E> implements InvocationHandler {
         DataType dt = dataType.getDataType();
 
         switch (dt.getName()) {
-					case TUPLE :
+          case TUPLE:
             Object childDsl = tupleMap.get(method);
 
             if (childDsl != null) {
@@ -178,16 +190,16 @@ public class DslInvocationHandler<E> implements InvocationHandler {
 
             break;
 
-					case SET :
+          case SET:
             return new SetDsl(new HelenusPropertyNode(prop, parent));
 
-					case LIST :
+          case LIST:
             return new ListDsl(new HelenusPropertyNode(prop, parent));
 
-					case MAP :
+          case MAP:
             return new MapDsl(new HelenusPropertyNode(prop, parent));
 
-					default :
+          default:
             break;
         }
       }

src/main/java/net/helenus/core/reflect/HelenusNamedProperty.java

@@ -19,9 +19,7 @@ import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.Optional;
 import java.util.function.Function;
-
 import javax.validation.ConstraintValidator;
-
 import net.helenus.core.SessionRepository;
 import net.helenus.mapping.*;
 import net.helenus.mapping.type.AbstractDataType;

src/main/java/net/helenus/core/reflect/HelenusPropertyNode.java

@@ -17,7 +17,6 @@ package net.helenus.core.reflect;
 
 import java.util.*;
 import java.util.stream.Collectors;
-
 import net.helenus.mapping.HelenusEntity;
 import net.helenus.mapping.HelenusProperty;
 

src/main/java/net/helenus/core/reflect/ListDsl.java

@@ -16,7 +16,6 @@
 package net.helenus.core.reflect;
 
 import java.util.*;
-
 import net.helenus.mapping.HelenusProperty;
 import net.helenus.support.DslPropertyException;
 import net.helenus.support.HelenusMappingException;

src/main/java/net/helenus/core/reflect/MapDsl.java

@@ -19,7 +19,6 @@ import java.util.Collection;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
-
 import net.helenus.mapping.HelenusProperty;
 import net.helenus.support.DslPropertyException;
 import net.helenus.support.HelenusMappingException;

src/main/java/net/helenus/core/reflect/MapperInvocationHandler.java

@@ -27,7 +27,6 @@ import java.lang.reflect.Proxy;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
-
 import net.helenus.core.Helenus;
 import net.helenus.mapping.annotation.Transient;
 import net.helenus.mapping.value.ValueProviderMap;
@@ -52,21 +51,26 @@ public class MapperInvocationHandler<E> implements InvocationHandler, Serializab
     // https://zeroturnaround.com/rebellabs/recognize-and-conquer-java-proxies-default-methods-and-method-handles/
 
     // First, we need an instance of a private inner-class found in MethodHandles.
-		Constructor<MethodHandles.Lookup> constructor = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class,
-				int.class);
+    Constructor<MethodHandles.Lookup> constructor =
+        MethodHandles.Lookup.class.getDeclaredConstructor(Class.class, int.class);
     constructor.setAccessible(true);
 
     // Now we need to lookup and invoke special the default method on the interface
     // class.
     final Class<?> declaringClass = method.getDeclaringClass();
-		Object result = constructor.newInstance(declaringClass, MethodHandles.Lookup.PRIVATE)
-				.unreflectSpecial(method, declaringClass).bindTo(proxy).invokeWithArguments(args);
+    Object result =
+        constructor
+            .newInstance(declaringClass, MethodHandles.Lookup.PRIVATE)
+            .unreflectSpecial(method, declaringClass)
+            .bindTo(proxy)
+            .invokeWithArguments(args);
     return result;
   }
 
   private Object writeReplace() {
     return new SerializationProxy<E>(this);
   }
+
   private void readObject(ObjectInputStream stream) throws InvalidObjectException {
     throw new InvalidObjectException("Proxy required.");
   }
@@ -179,6 +183,5 @@ public class MapperInvocationHandler<E> implements InvocationHandler, Serializab
     Object readResolve() throws ObjectStreamException {
       return new MapperInvocationHandler(iface, src);
     }
-
   }
 }

src/main/java/net/helenus/core/reflect/ReflectionDslInstantiator.java

@@ -15,11 +15,9 @@
  */
 package net.helenus.core.reflect;
 
+import com.datastax.driver.core.Metadata;
 import java.lang.reflect.Proxy;
 import java.util.Optional;
-
-import com.datastax.driver.core.Metadata;
-
 import net.helenus.core.DslInstantiator;
 
 public enum ReflectionDslInstantiator implements DslInstantiator {
@@ -27,10 +25,15 @@ public enum ReflectionDslInstantiator implements DslInstantiator {
 
   @Override
   @SuppressWarnings("unchecked")
-	public <E> E instantiate(Class<E> iface, ClassLoader classLoader, Optional<HelenusPropertyNode> parent,
+  public <E> E instantiate(
+      Class<E> iface,
+      ClassLoader classLoader,
+      Optional<HelenusPropertyNode> parent,
       Metadata metadata) {
-		DslInvocationHandler<E> handler = new DslInvocationHandler<E>(iface, classLoader, parent, metadata);
-		E proxy = (E) Proxy.newProxyInstance(classLoader, new Class[]{iface, DslExportable.class}, handler);
+    DslInvocationHandler<E> handler =
+        new DslInvocationHandler<E>(iface, classLoader, parent, metadata);
+    E proxy =
+        (E) Proxy.newProxyInstance(classLoader, new Class[] {iface, DslExportable.class}, handler);
     return proxy;
   }
 }

src/main/java/net/helenus/core/reflect/ReflectionInstantiator.java

@@ -19,8 +19,7 @@ import net.helenus.support.HelenusMappingException;
 
 public final class ReflectionInstantiator {
 
-	private ReflectionInstantiator() {
-	}
+  private ReflectionInstantiator() {}
 
   public static <T> T instantiateClass(Class<T> clazz) {
 

src/main/java/net/helenus/core/reflect/ReflectionMapperInstantiator.java

@@ -18,7 +18,6 @@ package net.helenus.core.reflect;
 import java.io.Serializable;
 import java.lang.reflect.Proxy;
 import java.util.Map;
-
 import net.helenus.core.MapperInstantiator;
 
 public enum ReflectionMapperInstantiator implements MapperInstantiator {
@@ -29,8 +28,10 @@ public enum ReflectionMapperInstantiator implements MapperInstantiator {
   public <E> E instantiate(Class<E> iface, Map<String, Object> src, ClassLoader classLoader) {
 
     MapperInvocationHandler<E> handler = new MapperInvocationHandler<E>(iface, src);
-		E proxy = (E) Proxy.newProxyInstance(classLoader, new Class[]{iface, MapExportable.class, Serializable.class},
-				handler);
+    E proxy =
+        (E)
+            Proxy.newProxyInstance(
+                classLoader, new Class[] {iface, MapExportable.class, Serializable.class}, handler);
     return proxy;
   }
 }

src/main/java/net/helenus/core/reflect/SetDsl.java

@@ -18,7 +18,6 @@ package net.helenus.core.reflect;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Set;
-
 import net.helenus.support.HelenusMappingException;
 
 public final class SetDsl<V> implements Set<V> {

src/main/java/net/helenus/mapping/ColumnInformation.java

@@ -16,7 +16,6 @@
 package net.helenus.mapping;
 
 import java.lang.reflect.Method;
-
 import net.helenus.mapping.annotation.ClusteringColumn;
 import net.helenus.mapping.annotation.Column;
 import net.helenus.mapping.annotation.PartitionKey;
@@ -103,13 +102,21 @@ public final class ColumnInformation {
   private void ensureSingleColumnType(ColumnType columnTypeLocal, Method getter) {
 
     if (columnTypeLocal != ColumnType.COLUMN) {
-			throw new HelenusMappingException("property can be annotated only by a single column type " + getter);
+      throw new HelenusMappingException(
+          "property can be annotated only by a single column type " + getter);
     }
   }
 
   @Override
   public String toString() {
-		return "ColumnInformation [columnName=" + columnName + ", columnType=" + columnType + ", ordinal=" + ordinal
-				+ ", ordering=" + ordering + "]";
+    return "ColumnInformation [columnName="
+        + columnName
+        + ", columnType="
+        + columnType
+        + ", ordinal="
+        + ordinal
+        + ", ordering="
+        + ordering
+        + "]";
   }
 }

src/main/java/net/helenus/mapping/ColumnType.java

@@ -16,5 +16,8 @@
 package net.helenus.mapping;
 
 public enum ColumnType {
-	PARTITION_KEY, CLUSTERING_COLUMN, STATIC_COLUMN, COLUMN;
+  PARTITION_KEY,
+  CLUSTERING_COLUMN,
+  STATIC_COLUMN,
+  COLUMN;
 }

src/main/java/net/helenus/mapping/HelenusEntity.java

@@ -17,7 +17,6 @@ package net.helenus.mapping;
 
 import java.util.Collection;
 import java.util.List;
-
 import net.helenus.core.cache.Facet;
 
 public interface HelenusEntity {

src/main/java/net/helenus/mapping/HelenusEntityType.java

@@ -16,5 +16,8 @@
 package net.helenus.mapping;
 
 public enum HelenusEntityType {
-	TABLE, VIEW, TUPLE, UDT;
+  TABLE,
+  VIEW,
+  TUPLE,
+  UDT;
 }

src/main/java/net/helenus/mapping/HelenusMappingEntity.java

@@ -15,18 +15,13 @@
  */
 package net.helenus.mapping;
 
-import java.lang.reflect.Method;
-import java.util.*;
-
-import javax.validation.ConstraintValidator;
-
-import org.apache.commons.lang3.ClassUtils;
-
 import com.datastax.driver.core.DefaultMetadata;
 import com.datastax.driver.core.Metadata;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
-
+import java.lang.reflect.Method;
+import java.util.*;
+import javax.validation.ConstraintValidator;
 import net.helenus.config.HelenusSettings;
 import net.helenus.core.Helenus;
 import net.helenus.core.annotation.Cacheable;
@@ -35,6 +30,7 @@ import net.helenus.core.cache.UnboundFacet;
 import net.helenus.mapping.annotation.*;
 import net.helenus.mapping.validator.DistinctValidator;
 import net.helenus.support.HelenusMappingException;
+import org.apache.commons.lang3.ClassUtils;
 
 public final class HelenusMappingEntity implements HelenusEntity {
 
@@ -69,7 +65,8 @@ public final class HelenusMappingEntity implements HelenusEntity {
     }
 
     for (Class<?> c : ClassUtils.getAllInterfaces(iface)) {
-			if (c.getDeclaredAnnotation(Table.class) != null || c.getDeclaredAnnotation(InheritedTable.class) != null) {
+      if (c.getDeclaredAnnotation(Table.class) != null
+          || c.getDeclaredAnnotation(InheritedTable.class) != null) {
         for (Method m : c.getDeclaredMethods()) {
           Method o = methods.get(m.getName());
           if (o != null) {
@@ -119,16 +116,17 @@ public final class HelenusMappingEntity implements HelenusEntity {
     facetsBuilder.add(new Facet("table", name.toCql()).setFixed());
     for (HelenusProperty prop : orderedProps) {
       switch (prop.getColumnType()) {
-				case PARTITION_KEY :
-				case CLUSTERING_COLUMN :
+        case PARTITION_KEY:
+        case CLUSTERING_COLUMN:
           primaryKeyProperties.add(prop);
           break;
-				default :
+        default:
           if (primaryKeyProperties != null && primaryKeyProperties.size() > 0) {
             facetsBuilder.add(new UnboundFacet(primaryKeyProperties));
             primaryKeyProperties = null;
           }
-					for (ConstraintValidator<?, ?> constraint : MappingUtil.getValidators(prop.getGetterMethod())) {
+          for (ConstraintValidator<?, ?> constraint :
+              MappingUtil.getValidators(prop.getGetterMethod())) {
             if (constraint.getClass().isAssignableFrom(DistinctValidator.class)) {
               UnboundFacet facet = new UnboundFacet(prop);
               facetsBuilder.add(facet);
@@ -146,16 +144,16 @@ public final class HelenusMappingEntity implements HelenusEntity {
   private static IdentityName resolveName(Class<?> iface, HelenusEntityType type) {
 
     switch (type) {
-			case TABLE :
+      case TABLE:
         return MappingUtil.getTableName(iface, true);
 
-			case VIEW :
+      case VIEW:
         return MappingUtil.getViewName(iface, true);
 
-			case TUPLE :
+      case TUPLE:
         return IdentityName.of(MappingUtil.getDefaultEntityName(iface), false);
 
-			case UDT :
+      case UDT:
         return MappingUtil.getUserDefinedTypeName(iface, true);
     }
 
@@ -176,7 +174,8 @@ public final class HelenusMappingEntity implements HelenusEntity {
       return HelenusEntityType.UDT;
     }
 
-		throw new HelenusMappingException("entity must be annotated by @Table or @Tuple or @UserDefinedType " + iface);
+    throw new HelenusMappingException(
+        "entity must be annotated by @Table or @Tuple or @UserDefinedType " + iface);
   }
 
   @Override
@@ -222,15 +221,15 @@ public final class HelenusMappingEntity implements HelenusEntity {
   private void validateOrdinals() {
 
     switch (getType()) {
-			case TABLE :
+      case TABLE:
         validateOrdinalsForTable();
         break;
 
-			case TUPLE :
+      case TUPLE:
         validateOrdinalsInTuple();
         break;
 
-			default :
+      default:
         break;
     }
   }
@@ -247,24 +246,29 @@ public final class HelenusMappingEntity implements HelenusEntity {
       int ordinal = prop.getOrdinal();
 
       switch (type) {
-				case PARTITION_KEY :
+        case PARTITION_KEY:
           if (partitionKeys.get(ordinal)) {
             throw new HelenusMappingException(
-								"detected two or more partition key columns with the same ordinal " + ordinal + " in "
+                "detected two or more partition key columns with the same ordinal "
+                    + ordinal
+                    + " in "
                     + prop.getEntity());
           }
           partitionKeys.set(ordinal);
           break;
 
-				case CLUSTERING_COLUMN :
+        case CLUSTERING_COLUMN:
           if (clusteringColumns.get(ordinal)) {
-						throw new HelenusMappingException("detected two or clustering columns with the same ordinal "
-								+ ordinal + " in " + prop.getEntity());
+            throw new HelenusMappingException(
+                "detected two or clustering columns with the same ordinal "
+                    + ordinal
+                    + " in "
+                    + prop.getEntity());
           }
           clusteringColumns.set(ordinal);
           break;
 
-				default :
+        default:
           break;
       }
     }
@@ -273,17 +277,27 @@ public final class HelenusMappingEntity implements HelenusEntity {
   private void validateOrdinalsInTuple() {
     boolean[] ordinals = new boolean[props.size()];
 
-		getOrderedProperties().forEach(p -> {
+    getOrderedProperties()
+        .forEach(
+            p -> {
               int ordinal = p.getOrdinal();
 
               if (ordinal < 0 || ordinal >= ordinals.length) {
-				throw new HelenusMappingException("invalid ordinal " + ordinal + " found for property "
-						+ p.getPropertyName() + " in " + p.getEntity());
+                throw new HelenusMappingException(
+                    "invalid ordinal "
+                        + ordinal
+                        + " found for property "
+                        + p.getPropertyName()
+                        + " in "
+                        + p.getEntity());
               }
 
               if (ordinals[ordinal]) {
                 throw new HelenusMappingException(
-						"detected two or more properties with the same ordinal " + ordinal + " in " + p.getEntity());
+                    "detected two or more properties with the same ordinal "
+                        + ordinal
+                        + " in "
+                        + p.getEntity());
               }
 
               ordinals[ordinal] = true;
@@ -300,8 +314,12 @@ public final class HelenusMappingEntity implements HelenusEntity {
   public String toString() {
 
     StringBuilder str = new StringBuilder();
-		str.append(iface.getSimpleName()).append("(").append(name.getName()).append(") ")
-				.append(type.name().toLowerCase()).append(":\n");
+    str.append(iface.getSimpleName())
+        .append("(")
+        .append(name.getName())
+        .append(") ")
+        .append(type.name().toLowerCase())
+        .append(":\n");
 
     for (HelenusProperty prop : getOrderedProperties()) {
       str.append(prop.toString());

src/main/java/net/helenus/mapping/HelenusMappingProperty.java

@@ -15,16 +15,13 @@
  */
 package net.helenus.mapping;
 
+import com.datastax.driver.core.Metadata;
 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.lang.reflect.Type;
 import java.util.Optional;
 import java.util.function.Function;
-
 import javax.validation.ConstraintValidator;
-
-import com.datastax.driver.core.Metadata;
-
 import net.helenus.core.SessionRepository;
 import net.helenus.mapping.javatype.AbstractJavaType;
 import net.helenus.mapping.javatype.MappingJavaTypes;
@@ -63,8 +60,9 @@ public final class HelenusMappingProperty implements HelenusProperty {
     this.javaType = getter.getReturnType();
     this.abstractJavaType = MappingJavaTypes.resolveJavaType(this.javaType);
 
-		this.dataType = abstractJavaType.resolveDataType(this.getter, this.genericJavaType,
-				this.columnInfo.getColumnType(), metadata);
+    this.dataType =
+        abstractJavaType.resolveDataType(
+            this.getter, this.genericJavaType, this.columnInfo.getColumnType(), metadata);
 
     this.validators = MappingUtil.getValidators(getter);
   }
@@ -168,13 +166,13 @@ public final class HelenusMappingProperty implements HelenusProperty {
     ColumnType type = this.getColumnType();
 
     switch (type) {
-			case PARTITION_KEY :
+      case PARTITION_KEY:
         str.append("partition_key[");
         str.append(this.getOrdinal());
         str.append("] ");
         break;
 
-			case CLUSTERING_COLUMN :
+      case CLUSTERING_COLUMN:
         str.append("clustering_column[");
         str.append(this.getOrdinal());
         str.append("] ");
@@ -184,11 +182,11 @@ public final class HelenusMappingProperty implements HelenusProperty {
         }
         break;
 
-			case STATIC_COLUMN :
+      case STATIC_COLUMN:
         str.append("static ");
         break;
 
-			case COLUMN :
+      case COLUMN:
         break;
     }
 

src/main/java/net/helenus/mapping/HelenusProperty.java

@@ -19,9 +19,7 @@ import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.util.Optional;
 import java.util.function.Function;
-
 import javax.validation.ConstraintValidator;
-
 import net.helenus.core.SessionRepository;
 import net.helenus.mapping.type.AbstractDataType;
 

src/main/java/net/helenus/mapping/MappingUtil.java

@@ -21,10 +21,8 @@ import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
-
 import javax.validation.Constraint;
 import javax.validation.ConstraintValidator;
-
 import net.helenus.core.Getter;
 import net.helenus.core.Helenus;
 import net.helenus.core.reflect.*;
@@ -35,10 +33,10 @@ import net.helenus.support.HelenusMappingException;
 public final class MappingUtil {
 
   @SuppressWarnings("unchecked")
-	public static final ConstraintValidator<? extends Annotation, ?>[] EMPTY_VALIDATORS = new ConstraintValidator[0];
+  public static final ConstraintValidator<? extends Annotation, ?>[] EMPTY_VALIDATORS =
+      new ConstraintValidator[0];
 
-	private MappingUtil() {
-	}
+  private MappingUtil() {}
 
   public static ConstraintValidator<? extends Annotation, ?>[] getValidators(Method getterMethod) {
 
@@ -63,8 +61,8 @@ public final class MappingUtil {
     }
   }
 
-	private static List<ConstraintValidator<? extends Annotation, ?>> addValidators(Annotation constraintAnnotation,
-			List<ConstraintValidator<? extends Annotation, ?>> list) {
+  private static List<ConstraintValidator<? extends Annotation, ?>> addValidators(
+      Annotation constraintAnnotation, List<ConstraintValidator<? extends Annotation, ?>> list) {
 
     Class<? extends Annotation> annotationType = constraintAnnotation.annotationType();
 
@@ -76,8 +74,8 @@ public final class MappingUtil {
 
         for (Class<? extends ConstraintValidator<?, ?>> clazz : constraint.validatedBy()) {
 
-					ConstraintValidator<? extends Annotation, ?> validator = ReflectionInstantiator
-							.instantiateClass(clazz);
+          ConstraintValidator<? extends Annotation, ?> validator =
+              ReflectionInstantiator.instantiateClass(clazz);
 
           ((ConstraintValidator) validator).initialize(constraintAnnotation);
 
@@ -109,7 +107,9 @@ public final class MappingUtil {
       }
     }
 
-		return indexName != null ? Optional.of(new IdentityName(indexName, forceQuote)) : Optional.empty();
+    return indexName != null
+        ? Optional.of(new IdentityName(indexName, forceQuote))
+        : Optional.empty();
   }
 
   public static boolean caseSensitiveIndex(Method getterMethod) {

src/main/java/net/helenus/mapping/TypeAndOrdinalColumnComparator.java

@@ -22,7 +22,8 @@ public enum TypeAndOrdinalColumnComparator implements Comparator<HelenusProperty
 
   public int compare(HelenusProperty thisVal, HelenusProperty anotherVal) {
 
-		int c = Integer.compare(thisVal.getColumnType().ordinal(), anotherVal.getColumnType().ordinal());
+    int c =
+        Integer.compare(thisVal.getColumnType().ordinal(), anotherVal.getColumnType().ordinal());
 
     if (c == 0) {
       c = Integer.compare(thisVal.getOrdinal(), anotherVal.getOrdinal());

src/main/java/net/helenus/mapping/annotation/ClusteringColumn.java

@@ -19,44 +19,34 @@ import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
-
 import net.helenus.mapping.OrderingDirection;
 
 /**
  * ClusteringColumn is the family column in legacy Cassandra API
  *
- * <p>
- * The purpose of this column is have additional dimension in the table.
- * Both @PartitionKey and @ClusteringColumn together are parts of the primary
- * key of the table. The primary difference between them is that the first one
- * is using for routing purposes in order to locate a data node in the cluster,
- * otherwise the second one is using inside the node to locate peace of data in
+ * <p>The purpose of this column is have additional dimension in the table. Both @PartitionKey
+ * and @ClusteringColumn together are parts of the primary key of the table. The primary difference
+ * between them is that the first one is using for routing purposes in order to locate a data node
+ * in the cluster, otherwise the second one is using inside the node to locate peace of data in
  * concrete machine.
  *
- * <p>
- * ClusteringColumn can be represented as a Key in SortedMap that fully stored
- * in a single node. All developers must be careful for selecting fields for
- * clustering columns, because all data inside this SortedMap must fit in to one
- * node.
+ * <p>ClusteringColumn can be represented as a Key in SortedMap that fully stored in a single node.
+ * All developers must be careful for selecting fields for clustering columns, because all data
+ * inside this SortedMap must fit in to one node.
  *
- * <p>
- * ClusteringColumn can have more than one part and the order of parts is
- * important. This order defines the way how Cassandra joins the parts and
- * influence of data retrieval operations. Each part can have ordering property
- * that defines default ascending or descending order of data. In case of two
- * and more parts in select queries developer needs to have consisdent order of
- * all parts as they defined in table.
+ * <p>ClusteringColumn can have more than one part and the order of parts is important. This order
+ * defines the way how Cassandra joins the parts and influence of data retrieval operations. Each
+ * part can have ordering property that defines default ascending or descending order of data. In
+ * case of two and more parts in select queries developer needs to have consisdent order of all
+ * parts as they defined in table.
  *
- * <p>
- * For example, first part is ASC ordering, second is also ASC, so Cassandra
- * will sort entries like this: a-a a-b b-a b-b In this case we are able run
- * queries: ORDER BY first ASC, second ASC ORDER BY first DESC, second DESC
- * WHERE first=? ORDER BY second ASC WHERE first=? ORDER BY second DESC WHERE
- * first=? AND second=?
+ * <p>For example, first part is ASC ordering, second is also ASC, so Cassandra will sort entries
+ * like this: a-a a-b b-a b-b In this case we are able run queries: ORDER BY first ASC, second ASC
+ * ORDER BY first DESC, second DESC WHERE first=? ORDER BY second ASC WHERE first=? ORDER BY second
+ * DESC WHERE first=? AND second=?
  *
- * <p>
- * But, we can not run queries: ORDER BY first DESC, second ASC ORDER BY first
- * ASC, second DESC WHERE second=? ORDER BY first (ASC,DESC)
+ * <p>But, we can not run queries: ORDER BY first DESC, second ASC ORDER BY first ASC, second DESC
+ * WHERE second=? ORDER BY first (ASC,DESC)
  */
 @Retention(value = RetentionPolicy.RUNTIME)
 @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@@ -70,40 +60,35 @@ public @interface ClusteringColumn {
   String value() default "";
 
   /**
-	 * ClusteringColumn parts must be ordered in the @Table. It is the requirement
-	 * of Cassandra. Cassandra joins all parts to the final clustering key that is
-	 * stored in column family name. Additionally all parts can have some ordering
-	 * (ASC, DESC) that with sequence of parts determines key comparison function,
-	 * so Cassandra storing column family names always in sorted order.
+   * ClusteringColumn parts must be ordered in the @Table. It is the requirement of Cassandra.
+   * Cassandra joins all parts to the final clustering key that is stored in column family name.
+   * Additionally all parts can have some ordering (ASC, DESC) that with sequence of parts
+   * determines key comparison function, so Cassandra storing column family names always in sorted
+   * order.
    *
-	 * <p>
-	 * Be default ordinal has 0 value, that's because in most cases @Table have
-	 * single column for ClusteringColumn If you have 2 and more parts of the
-	 * ClusteringColumn, then you need to use ordinal() to define the sequence of
-	 * the parts
+   * <p>Be default ordinal has 0 value, that's because in most cases @Table have single column for
+   * ClusteringColumn If you have 2 and more parts of the ClusteringColumn, then you need to use
+   * ordinal() to define the sequence of the parts
    *
    * @return number that used to sort clustering columns
    */
   int ordinal() default 0;
 
   /**
-	 * Default order of values in the ClusteringColumn This ordering is using for
-	 * comparison of the clustering column values when Cassandra stores it in the
-	 * sorted order.
+   * Default order of values in the ClusteringColumn This ordering is using for comparison of the
+   * clustering column values when Cassandra stores it in the sorted order.
    *
-	 * <p>
-	 * Default value is the ascending order
+   * <p>Default value is the ascending order
    *
    * @return ascending order or descending order of clustering column values
    */
   OrderingDirection ordering() default OrderingDirection.ASC;
 
   /**
-	 * For reserved words in Cassandra we need quotation in CQL queries. This
-	 * property marks that the name of the UDT type needs to be quoted.
+   * For reserved words in Cassandra we need quotation in CQL queries. This property marks that the
+   * name of the UDT type needs to be quoted.
    *
-	 * <p>
-	 * Default value is false, we are quoting only selected names.
+   * <p>Default value is false, we are quoting only selected names.
    *
    * @return true if name have to be quoted
    */

src/main/java/net/helenus/mapping/annotation/Column.java

@@ -18,18 +18,15 @@ package net.helenus.mapping.annotation;
 import java.lang.annotation.*;
 
 /**
- * Column annotation is used to define additional properties of the column in
- * entity mapping interfaces: @Table, @UDT, @Tuple
+ * Column annotation is used to define additional properties of the column in entity mapping
+ * interfaces: @Table, @UDT, @Tuple
  *
- * <p>
- * Column annotation can be used to override default name of the column or to
- * setup order of the columns in the mapping
+ * <p>Column annotation can be used to override default name of the column or to setup order of the
+ * columns in the mapping
  *
- * <p>
- * Usually for @Table and @UDT types it is not important to define order of the
- * columns, but in @Tuple mapping it is required, because tuple itself
- * represents the sequence of the types with particular order in the table's
- * column
+ * <p>Usually for @Table and @UDT types it is not important to define order of the columns, but
+ * in @Tuple mapping it is required, because tuple itself represents the sequence of the types with
+ * particular order in the table's column
  */
 @Documented
 @Retention(RetentionPolicy.RUNTIME)
@@ -46,21 +43,18 @@ public @interface Column {
   /**
    * Ordinal will be used for ascending sorting of columns
    *
-	 * <p>
-	 * Default value is 0, because not all mapping entities require all fields to
-	 * have unique ordinals, only @Tuple mapping entity requires all of them to be
-	 * unique.
+   * <p>Default value is 0, because not all mapping entities require all fields to have unique
+   * ordinals, only @Tuple mapping entity requires all of them to be unique.
    *
    * @return number that used to sort columns, usually for @Tuple only
    */
   int ordinal() default 0;
 
   /**
-	 * For reserved words in Cassandra we need quotation in CQL queries. This
-	 * property marks that the name of the UDT type needs to be quoted.
+   * For reserved words in Cassandra we need quotation in CQL queries. This property marks that the
+   * name of the UDT type needs to be quoted.
    *
-	 * <p>
-	 * Default value is false, we are quoting only selected names.
+   * <p>Default value is false, we are quoting only selected names.
    *
    * @return true if name have to be quoted
    */

src/main/java/net/helenus/mapping/annotation/Constraints.java

@@ -16,106 +16,83 @@
 package net.helenus.mapping.annotation;
 
 import java.lang.annotation.*;
-
 import javax.validation.Constraint;
-
 import net.helenus.mapping.validator.*;
 
 /**
- * Constraint annotations are using for data integrity mostly
- * for @java.lang.String types. The place of the annotation is the particular
- * method in model interface.
+ * Constraint annotations are using for data integrity mostly for @java.lang.String types. The place
+ * of the annotation is the particular method in model interface.
  *
- * <p>
- * All of them does not have effect on selects and data retrieval operations.
+ * <p>All of them does not have effect on selects and data retrieval operations.
  *
- * <p>
- * Support types: - @NotNull supports any @java.lang.Object type - All
- * annotations support @java.lang.String type
+ * <p>Support types: - @NotNull supports any @java.lang.Object type - All annotations
+ * support @java.lang.String type
  */
 public final class Constraints {
 
-	private Constraints() {
-	}
+  private Constraints() {}
 
   /**
    * NotNull annotation is using to check that value is not null before storing it
    *
-	 * <p>
-	 * Applicable to use in any @java.lang.Object
+   * <p>Applicable to use in any @java.lang.Object
    *
-	 * <p>
-	 * It does not check on selects and data retrieval operations
+   * <p>It does not check on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
   @Constraint(validatedBy = NotNullValidator.class)
-	public @interface NotNull {
-	}
+  public @interface NotNull {}
 
   /**
    * NotEmpty annotation is using to check that value has text before storing it
    *
-	 * <p>
-	 * Also checks for the null and it is more strict annotation then @NotNull
+   * <p>Also checks for the null and it is more strict annotation then @NotNull
    *
-	 * <p>
-	 * Can be used for @java.lang.CharSequence, @ByteBuffer and any array
+   * <p>Can be used for @java.lang.CharSequence, @ByteBuffer and any array
    *
-	 * <p>
-	 * It does not check on selects and data retrieval operations
+   * <p>It does not check on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
   @Constraint(validatedBy = NotEmptyValidator.class)
-	public @interface NotEmpty {
-	}
+  public @interface NotEmpty {}
 
   /**
-	 * Email annotation is using to check that value has a valid email before
-	 * storing it
+   * Email annotation is using to check that value has a valid email before storing it
    *
-	 * <p>
-	 * Can be used only for @CharSequence
+   * <p>Can be used only for @CharSequence
    *
-	 * <p>
-	 * It does not check on selects and data retrieval operations
+   * <p>It does not check on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
   @Constraint(validatedBy = EmailValidator.class)
-	public @interface Email {
-	}
+  public @interface Email {}
 
   /**
-	 * Number annotation is using to check that all letters in value are digits
-	 * before storing it
+   * Number annotation is using to check that all letters in value are digits before storing it
    *
-	 * <p>
-	 * Can be used only for @java.lang.CharSequence
+   * <p>Can be used only for @java.lang.CharSequence
    *
-	 * <p>
-	 * It does not check on selects and data retrieval operations
+   * <p>It does not check on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
   @Constraint(validatedBy = NumberValidator.class)
-	public @interface Number {
-	}
+  public @interface Number {}
 
   /**
-	 * Alphabet annotation is using to check that all letters in value are in
-	 * specific alphabet before storing it
+   * Alphabet annotation is using to check that all letters in value are in specific alphabet before
+   * storing it
    *
-	 * <p>
-	 * Can be used only for @java.lang.CharSequence
+   * <p>Can be used only for @java.lang.CharSequence
    *
-	 * <p>
-	 * It does not check on selects and data retrieval operations
+   * <p>It does not check on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -132,14 +109,11 @@ public final class Constraints {
   }
 
   /**
-	 * Length annotation is using to ensure that value has exact length before
-	 * storing it
+   * Length annotation is using to ensure that value has exact length before storing it
    *
-	 * <p>
-	 * Can be used for @java.lang.CharSequence, @ByteBuffer and any array
+   * <p>Can be used for @java.lang.CharSequence, @ByteBuffer and any array
    *
-	 * <p>
-	 * It does not have effect on selects and data retrieval operations
+   * <p>It does not have effect on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -151,14 +125,12 @@ public final class Constraints {
   }
 
   /**
-	 * MaxLength annotation is using to ensure that value has length less or equal
-	 * to some threshold before storing it
+   * MaxLength annotation is using to ensure that value has length less or equal to some threshold
+   * before storing it
    *
-	 * <p>
-	 * Can be used for @java.lang.CharSequence, @ByteBuffer and byte[]
+   * <p>Can be used for @java.lang.CharSequence, @ByteBuffer and byte[]
    *
-	 * <p>
-	 * It does not have effect on selects and data retrieval operations
+   * <p>It does not have effect on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -170,14 +142,12 @@ public final class Constraints {
   }
 
   /**
-	 * MinLength annotation is using to ensure that value has length greater or
-	 * equal to some threshold before storing it
+   * MinLength annotation is using to ensure that value has length greater or equal to some
+   * threshold before storing it
    *
-	 * <p>
-	 * Can be used for @java.lang.CharSequence, @ByteBuffer and byte[]
+   * <p>Can be used for @java.lang.CharSequence, @ByteBuffer and byte[]
    *
-	 * <p>
-	 * It does not have effect on selects and data retrieval operations
+   * <p>It does not have effect on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -189,48 +159,38 @@ public final class Constraints {
   }
 
   /**
-	 * LowerCase annotation is using to ensure that value is in lower case before
-	 * storing it
+   * LowerCase annotation is using to ensure that value is in lower case before storing it
    *
-	 * <p>
-	 * Can be used only for @java.lang.CharSequence
+   * <p>Can be used only for @java.lang.CharSequence
    *
-	 * <p>
-	 * It does not have effect on selects and data retrieval operations
+   * <p>It does not have effect on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
   @Constraint(validatedBy = LowerCaseValidator.class)
-	public @interface LowerCase {
-	}
+  public @interface LowerCase {}
 
   /**
-	 * UpperCase annotation is using to ensure that value is in upper case before
-	 * storing it
+   * UpperCase annotation is using to ensure that value is in upper case before storing it
    *
-	 * <p>
-	 * Can be used only for @java.lang.CharSequence
+   * <p>Can be used only for @java.lang.CharSequence
    *
-	 * <p>
-	 * It does not have effect on selects and data retrieval operations
+   * <p>It does not have effect on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
   @Constraint(validatedBy = UpperCaseValidator.class)
-	public @interface UpperCase {
-	}
+  public @interface UpperCase {}
 
   /**
-	 * Pattern annotation is LowerCase annotation is using to ensure that value is
-	 * upper case before storing it
+   * Pattern annotation is LowerCase annotation is using to ensure that value is upper case before
+   * storing it
    *
-	 * <p>
-	 * Can be used only for @java.lang.CharSequence
+   * <p>Can be used only for @java.lang.CharSequence
    *
-	 * <p>
-	 * It does not have effect on selects and data retrieval operations
+   * <p>It does not have effect on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -254,14 +214,12 @@ public final class Constraints {
   }
 
   /**
-	 * Distinct annotation is used to signal, but not ensure that a value should be
-	 * distinct in the database.
+   * Distinct annotation is used to signal, but not ensure that a value should be distinct in the
+   * database.
    *
-	 * <p>
-	 * Can be used only for @java.lang.CharSequence
+   * <p>Can be used only for @java.lang.CharSequence
    *
-	 * <p>
-	 * It does not have effect on selects and data retrieval operations
+   * <p>It does not have effect on selects and data retrieval operations
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -275,6 +233,5 @@ public final class Constraints {
      * @return Java
      */
     Class<? extends Enum> value() default Enum.class;
-
   }
 }

src/main/java/net/helenus/mapping/annotation/CoveringIndex.java

@@ -3,20 +3,17 @@ package net.helenus.mapping.annotation;
 import java.lang.annotation.*;
 
 /**
- * CoveringIndex annotation is using under the specific column or method in
- * entity interface with @Table annotation.
+ * CoveringIndex annotation is using under the specific column or method in entity interface
+ * with @Table annotation.
  *
- * <p>
- * A corresponding materialized view will be created based on the
- * underline @Table for the specific column.
+ * <p>A corresponding materialized view will be created based on the underline @Table for the
+ * specific column.
  *
- * <p>
- * This is useful when you need to perform IN or SORT/ORDER-BY queries and to do
- * so you'll need different materialized table on disk in Cassandra.
+ * <p>This is useful when you need to perform IN or SORT/ORDER-BY queries and to do so you'll need
+ * different materialized table on disk in Cassandra.
  *
- * <p>
- * For each @Table annotated interface Helenus will create/update/verify
- * Cassandra Materialized Views and some indexes if needed on startup.
+ * <p>For each @Table annotated interface Helenus will create/update/verify Cassandra Materialized
+ * Views and some indexes if needed on startup.
  */
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
@@ -24,8 +21,7 @@ import java.lang.annotation.*;
 public @interface CoveringIndex {
 
   /**
-	 * Defined the name of the index. By default the entity name with column name as
-	 * suffix.
+   * Defined the name of the index. By default the entity name with column name as suffix.
    *
    * @return name of the covering index
    */

src/main/java/net/helenus/mapping/annotation/Index.java

@@ -18,22 +18,18 @@ package net.helenus.mapping.annotation;
 import java.lang.annotation.*;
 
 /**
- * Index annotation is using under the specific column or method in entity
- * interface with @Table annotation.
+ * Index annotation is using under the specific column or method in entity interface with @Table
+ * annotation.
  *
- * <p>
- * The corresponding secondary index will be created in the underline @Table for
- * the specific column.
+ * <p>The corresponding secondary index will be created in the underline @Table for the specific
+ * column.
  *
- * <p>
- * Currently Cassandra supports only single column index, so this index works
- * only for single column.
+ * <p>Currently Cassandra supports only single column index, so this index works only for single
+ * column.
  *
- * <p>
- * Make sure that you are using low cardinality columns for this index, that is
- * the requirement of the Cassandra. Low cardinality fields examples: gender,
- * country, age, status and etc High cardinality fields examples: id, email,
- * timestamp, UUID and etc
+ * <p>Make sure that you are using low cardinality columns for this index, that is the requirement
+ * of the Cassandra. Low cardinality fields examples: gender, country, age, status and etc High
+ * cardinality fields examples: id, email, timestamp, UUID and etc
  */
 @Documented
 @Retention(RetentionPolicy.RUNTIME)
@@ -48,27 +44,22 @@ public @interface Index {
   String value() default "";
 
   /**
-	 * For reserved words in Cassandra we need quotation in CQL queries. This
-	 * property marks that the name of the UDT type needs to be quoted.
+   * For reserved words in Cassandra we need quotation in CQL queries. This property marks that the
+   * name of the UDT type needs to be quoted.
    *
-	 * <p>
-	 * Default value is false, we are quoting only selected names.
+   * <p>Default value is false, we are quoting only selected names.
    *
    * @return true if name have to be quoted
    */
   boolean forceQuote() default false;
 
   /**
-	 * Create a case-insensitive index using Cassandra 3.x+ support for SASI
-	 * indexing.
+   * Create a case-insensitive index using Cassandra 3.x+ support for SASI indexing.
    *
    * @return true if the index should ignore case when comparing
    */
   boolean caseSensitive() default true;
 
-	/**
-	 *
-	 * @return
-	 */
+  /** @return */
   boolean distinct() default false;
 }

src/main/java/net/helenus/mapping/annotation/InheritedTable.java

@@ -20,9 +20,7 @@ import java.lang.annotation.*;
 /**
  * Inherited Entity annotation
  *
- * <p>
- * Inherited Table annotation is used to indicate that the methods should also
- * be mapped
+ * <p>Inherited Table annotation is used to indicate that the methods should also be mapped
  */
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)

src/main/java/net/helenus/mapping/annotation/MaterializedView.java

@@ -20,17 +20,13 @@ import java.lang.annotation.*;
 /**
  * Materialized alternate view of another Entity annotation
  *
- * <p>
- * MaterializedView annotation is used to define different mapping to some other
- * Table interface
+ * <p>MaterializedView annotation is used to define different mapping to some other Table interface
  *
- * <p>
- * This is useful when you need to perform IN or SORT/ORDER-BY queries and to do
- * so you'll need different materialized table on disk in Cassandra.
+ * <p>This is useful when you need to perform IN or SORT/ORDER-BY queries and to do so you'll need
+ * different materialized table on disk in Cassandra.
  *
- * <p>
- * For each @Table annotated interface Helenus will create/update/verify
- * Cassandra Materialized Views and some indexes if needed on startup.
+ * <p>For each @Table annotated interface Helenus will create/update/verify Cassandra Materialized
+ * Views and some indexes if needed on startup.
  */
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
@@ -45,11 +41,10 @@ public @interface MaterializedView {
   String value() default "";
 
   /**
-	 * For reserved words in Cassandra we need quotation in CQL queries. This
-	 * property marks that the name of the type needs to be quoted.
+   * For reserved words in Cassandra we need quotation in CQL queries. This property marks that the
+   * name of the type needs to be quoted.
    *
-	 * <p>
-	 * Default value is false, we are quoting only selected names.
+   * <p>Default value is false, we are quoting only selected names.
    *
    * @return true if name have to be quoted
    */

src/main/java/net/helenus/mapping/annotation/PartitionKey.java

@@ -21,20 +21,16 @@ import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * PartitionKey annotation is using to define that particular column is the part
- * of partition key in the table.
+ * PartitionKey annotation is using to define that particular column is the part of partition key in
+ * the table.
  *
- * <p>
- * Partition Key is the routing key. Cassandra is using it to find the primary
- * data node in the cluster that holds data. Cassandra combines all parts of the
- * partition key to byte array and then calculates hash function by using good
- * distribution algorithm (by default MurMur3). After that it uses hash number
- * as a token in the ring to find a virtual and then a physical data server.
+ * <p>Partition Key is the routing key. Cassandra is using it to find the primary data node in the
+ * cluster that holds data. Cassandra combines all parts of the partition key to byte array and then
+ * calculates hash function by using good distribution algorithm (by default MurMur3). After that it
+ * uses hash number as a token in the ring to find a virtual and then a physical data server.
  *
- * <p>
- * For @Table mapping entity it is required to have as minimum one PartitionKey
- * column. For @UDT and @Tuple mapping entities @PartitionKey annotation is not
- * using.
+ * <p>For @Table mapping entity it is required to have as minimum one PartitionKey column. For @UDT
+ * and @Tuple mapping entities @PartitionKey annotation is not using.
  */
 @Retention(value = RetentionPolicy.RUNTIME)
 @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@@ -48,26 +44,23 @@ public @interface PartitionKey {
   String value() default "";
 
   /**
-	 * PartitionKey parts must be ordered in the @Table. It is the requirement of
-	 * Cassandra. That is how the partition key calculation works, column parts will
-	 * be joined based on some order and final hash/token will be calculated.
+   * PartitionKey parts must be ordered in the @Table. It is the requirement of Cassandra. That is
+   * how the partition key calculation works, column parts will be joined based on some order and
+   * final hash/token will be calculated.
    *
-	 * <p>
-	 * Be default ordinal has 0 value, that's because in most cases @Table have
-	 * single column for @PartitionKey If you have 2 and more parts of the
-	 * PartitionKey, then you need to use ordinal() to define the sequence of the
-	 * parts
+   * <p>Be default ordinal has 0 value, that's because in most cases @Table have single column
+   * for @PartitionKey If you have 2 and more parts of the PartitionKey, then you need to use
+   * ordinal() to define the sequence of the parts
    *
    * @return number that used to sort columns in PartitionKey
    */
   int ordinal() default 0;
 
   /**
-	 * For reserved words in Cassandra we need quotation in CQL queries. This
-	 * property marks that the name of the UDT type needs to be quoted.
+   * For reserved words in Cassandra we need quotation in CQL queries. This property marks that the
+   * name of the UDT type needs to be quoted.
    *
-	 * <p>
-	 * Default value is false, we are quoting only selected names.
+   * <p>Default value is false, we are quoting only selected names.
    *
    * @return true if name have to be quoted
    */

src/main/java/net/helenus/mapping/annotation/StaticColumn.java

@@ -23,14 +23,12 @@ import java.lang.annotation.Target;
 /**
  * StaticColumn annotation is using to define a static column in Cassandra Table
  *
- * <p>
- * It does not have effect in @UDT and @Tuple types and in @Table-s that does
- * not have @ClusteringColumn-s
+ * <p>It does not have effect in @UDT and @Tuple types and in @Table-s that does not
+ * have @ClusteringColumn-s
  *
- * <p>
- * In case of using @ClusteringColumn we can repeat some information that is
- * unique for a row. For this purpose we can define @StaticColumn annotation,
- * that will create static column in the table
+ * <p>In case of using @ClusteringColumn we can repeat some information that is unique for a row.
+ * For this purpose we can define @StaticColumn annotation, that will create static column in the
+ * table
  */
 @Retention(value = RetentionPolicy.RUNTIME)
 @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@@ -51,11 +49,10 @@ public @interface StaticColumn {
   int ordinal() default 0;
 
   /**
-	 * For reserved words in Cassandra we need quotation in CQL queries. This
-	 * property marks that the name of the UDT type needs to be quoted.
+   * For reserved words in Cassandra we need quotation in CQL queries. This property marks that the
+   * name of the UDT type needs to be quoted.
    *
-	 * <p>
-	 * Default value is false, we are quoting only selected names.
+   * <p>Default value is false, we are quoting only selected names.
    *
    * @return true if name have to be quoted
    */

src/main/java/net/helenus/mapping/annotation/Table.java

@@ -20,15 +20,12 @@ import java.lang.annotation.*;
 /**
  * Entity annotation
  *
- * <p>
- * Table annotation is used to define Table mapping to some interface
+ * <p>Table annotation is used to define Table mapping to some interface
  *
- * <p>
- * There are three types of Entity mapping annotations: @Table, @UDT, @Tuple
+ * <p>There are three types of Entity mapping annotations: @Table, @UDT, @Tuple
  *
- * <p>
- * For each @Table annotated interface Helenus will create/update/verify
- * Cassandra Table and some indexes if needed on startup.
+ * <p>For each @Table annotated interface Helenus will create/update/verify Cassandra Table and some
+ * indexes if needed on startup.
  */
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
@@ -43,11 +40,10 @@ public @interface Table {
   String value() default "";
 
   /**
-	 * For reserved words in Cassandra we need quotation in CQL queries. This
-	 * property marks that the name of the UDT type needs to be quoted.
+   * For reserved words in Cassandra we need quotation in CQL queries. This property marks that the
+   * name of the UDT type needs to be quoted.
    *
-	 * <p>
-	 * Default value is false, we are quoting only selected names.
+   * <p>Default value is false, we are quoting only selected names.
    *
    * @return true if name have to be quoted
    */

src/main/java/net/helenus/mapping/annotation/Transient.java

@@ -17,12 +17,8 @@ package net.helenus.mapping.annotation;
 
 import java.lang.annotation.*;
 
-/**
- * Transient annotation is used to mark properties that are need not be mapped
- * to the database.
- */
+/** Transient annotation is used to mark properties that are need not be mapped to the database. */
 @Documented
 @Retention(RetentionPolicy.RUNTIME)
 @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-public @interface Transient {
-}
+public @interface Transient {}

src/main/java/net/helenus/mapping/annotation/Tuple.java

@@ -20,19 +20,15 @@ import java.lang.annotation.*;
 /**
  * Entity annotation
  *
- * <p>
- * Tuple annotation is used to define Tuple type mapping to some interface
+ * <p>Tuple annotation is used to define Tuple type mapping to some interface
  *
- * <p>
- * There are three types of Entity mapping annotations: @Table, @UDT, @Tuple
+ * <p>There are three types of Entity mapping annotations: @Table, @UDT, @Tuple
  *
- * <p>
- * Tuple is fully embedded type, it is the sequence of the underline types and
- * the order of the sub-types is important, therefore all @Column-s must have
- * ordinal() and only @Column annotation supported for underline types
+ * <p>Tuple is fully embedded type, it is the sequence of the underline types and the order of the
+ * sub-types is important, therefore all @Column-s must have ordinal() and only @Column annotation
+ * supported for underline types
  */
 @Inherited
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ElementType.TYPE})
-public @interface Tuple {
-}
+public @interface Tuple {}

src/main/java/net/helenus/mapping/annotation/Types.java

@@ -15,79 +15,62 @@
  */
 package net.helenus.mapping.annotation;
 
+import com.datastax.driver.core.DataType;
 import java.lang.annotation.*;
 
-import com.datastax.driver.core.DataType;
-
 /**
- * Types annotations are using for clarification of Cassandra data type for
- * particular Java type.
+ * Types annotations are using for clarification of Cassandra data type for particular Java type.
  *
- * <p>
- * Sometimes it is possible to have for single Java type multiple Cassandra data
- * types: - @String can be @DataType.Name.ASCII or @DataType.Name.TEXT
- * or @DataType.Name.VARCHAR - @Long can be @DataType.Name.BIGINT
- * or @DataType.Name.COUNTER
+ * <p>Sometimes it is possible to have for single Java type multiple Cassandra data types: - @String
+ * can be @DataType.Name.ASCII or @DataType.Name.TEXT or @DataType.Name.VARCHAR - @Long can
+ * be @DataType.Name.BIGINT or @DataType.Name.COUNTER
  *
- * <p>
- * All those type annotations simplify mapping between Java types and Cassandra
- * data types. They are not required, for each Java type there is a default
- * Cassandra data type in Helenus, but in some cases you would like to control
- * mapping to make sure that the right Cassandra data type is using.
+ * <p>All those type annotations simplify mapping between Java types and Cassandra data types. They
+ * are not required, for each Java type there is a default Cassandra data type in Helenus, but in
+ * some cases you would like to control mapping to make sure that the right Cassandra data type is
+ * using.
  *
- * <p>
- * For complex types like collections, UDF and Tuple types all those annotations
- * are using to clarify the sub-type(s) or class/UDF names.
+ * <p>For complex types like collections, UDF and Tuple types all those annotations are using to
+ * clarify the sub-type(s) or class/UDF names.
  *
- * <p>
- * Has significant effect on schema operations.
+ * <p>Has significant effect on schema operations.
  */
 public final class Types {
 
-	private Types() {
-	}
+  private Types() {}
 
   /** Says to use @DataType.Name.ASCII data type in schema Java type is @String */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-	public @interface Ascii {
-	}
+  public @interface Ascii {}
 
   /** Says to use @DataType.Name.BIGINT data type in schema Java type is @Long */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-	public @interface Bigint {
-	}
+  public @interface Bigint {}
 
   /**
-	 * Says to use @DataType.Name.BLOB data type in schema Java type is @ByteBuffer
-	 * or @byte[] Using by default
+   * Says to use @DataType.Name.BLOB data type in schema Java type is @ByteBuffer or @byte[] Using
+   * by default
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-	public @interface Blob {
-	}
+  public @interface Blob {}
 
   /**
-	 * Says to use @DataType.Name.LIST data type in schema with specific sub-type
-	 * Java type is @List
+   * Says to use @DataType.Name.LIST data type in schema with specific sub-type Java type is @List
    *
-	 * <p>
-	 * Helenus does not allow to use a specific implementation of the collection
-	 * thereof data retrieval operation result can be a collection with another
-	 * implementation.
+   * <p>Helenus does not allow to use a specific implementation of the collection thereof data
+   * retrieval operation result can be a collection with another implementation.
    *
-	 * <p>
-	 * This annotation is usually used only for sub-types clarification and only in
-	 * case if sub-type is Java type that corresponds to multiple Cassandra data
-	 * types.
+   * <p>This annotation is usually used only for sub-types clarification and only in case if
+   * sub-type is Java type that corresponds to multiple Cassandra data types.
    *
-	 * <p>
-	 * For this type there are special operations: prepend, prependAll, setIdx,
-	 * append, appendAll, discard and discardAll in @UpdateOperation
+   * <p>For this type there are special operations: prepend, prependAll, setIdx, append, appendAll,
+   * discard and discardAll in @UpdateOperation
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -95,11 +78,10 @@ public final class Types {
   public @interface List {
 
     /**
-		 * Clarification of using the sub-type data type in the collection. It supports
-		 * only simple data type (not Collection, UDT or Tuple)
+     * Clarification of using the sub-type data type in the collection. It supports only simple data
+     * type (not Collection, UDT or Tuple)
      *
-		 * <p>
-		 * In case if you need UDT sub-type in the list, consider @UDTList annotation
+     * <p>In case if you need UDT sub-type in the list, consider @UDTList annotation
      *
      * @return data type name of the value
      */
@@ -107,22 +89,15 @@ public final class Types {
   }
 
   /**
-	 * Says to use @DataType.Name.MAP data type in schema with specific sub-types
-	 * Java type is @Map
+   * Says to use @DataType.Name.MAP data type in schema with specific sub-types Java type is @Map
    *
-	 * <p>
-	 * Helenus does not allow to use a specific implementation of the collection
-	 * thereof data retrieval operation result can be a collection with another
-	 * implementation.
+   * <p>Helenus does not allow to use a specific implementation of the collection thereof data
+   * retrieval operation result can be a collection with another implementation.
    *
-	 * <p>
-	 * This annotation is usually used only for sub-types clarification and only in
-	 * case if sub-type is Java type that corresponds to multiple Cassandra data
-	 * types.
+   * <p>This annotation is usually used only for sub-types clarification and only in case if
+   * sub-type is Java type that corresponds to multiple Cassandra data types.
    *
-	 * <p>
-	 * For this type there are special operations: put and putAll
-	 * in @UpdateOperation.
+   * <p>For this type there are special operations: put and putAll in @UpdateOperation.
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -130,24 +105,22 @@ public final class Types {
   public @interface Map {
 
     /**
-		 * Clarification of using the sub-type data type in the collection. It supports
-		 * only simple data type (not Collection, UDT or Tuple)
+     * Clarification of using the sub-type data type in the collection. It supports only simple data
+     * type (not Collection, UDT or Tuple)
      *
-		 * <p>
-		 * In case if you need UDT key sub-type in the map, consider @UDTKeyMap
-		 * or @UDTMap annotations
+     * <p>In case if you need UDT key sub-type in the map, consider @UDTKeyMap or @UDTMap
+     * annotations
      *
      * @return data type name of the key
      */
     DataType.Name key();
 
     /**
-		 * Clarification of using the sub-type data type in the collection. It supports
-		 * only simple data type (not Collection, UDT or Tuple)
+     * Clarification of using the sub-type data type in the collection. It supports only simple data
+     * type (not Collection, UDT or Tuple)
      *
-		 * <p>
-		 * In case if you need UDT value sub-type in the map, consider @UDTValueMap
-		 * or @UDTMap annotations
+     * <p>In case if you need UDT value sub-type in the map, consider @UDTValueMap or @UDTMap
+     * annotations
      *
      * @return data type name of the value
      */
@@ -157,33 +130,24 @@ public final class Types {
   /**
    * Says to use @DataType.Name.COUNTER type in schema Java type is @Long
    *
-	 * <p>
-	 * For this type there are special operations: increment and decrement
-	 * in @UpdateOperation. You do not need to initialize counter value, it will be
-	 * done automatically by Cassandra.
+   * <p>For this type there are special operations: increment and decrement in @UpdateOperation. You
+   * do not need to initialize counter value, it will be done automatically by Cassandra.
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-	public @interface Counter {
-	}
+  public @interface Counter {}
 
   /**
-	 * Says to use @DataType.Name.SET data type in schema with specific sub-type
-	 * Java type is @Set
+   * Says to use @DataType.Name.SET data type in schema with specific sub-type Java type is @Set
    *
-	 * <p>
-	 * Helenus does not allow to use a specific implementation of the collection
-	 * thereof data retrieval operation result can be a collection with another
-	 * implementation.
+   * <p>Helenus does not allow to use a specific implementation of the collection thereof data
+   * retrieval operation result can be a collection with another implementation.
    *
-	 * <p>
-	 * This annotation is usually used only for sub-types clarification and only in
-	 * case if sub-type is Java type that corresponds to multiple Cassandra data
-	 * types.
+   * <p>This annotation is usually used only for sub-types clarification and only in case if
+   * sub-type is Java type that corresponds to multiple Cassandra data types.
    *
-	 * <p>
-	 * For this type there are special operations: add, addAll, remove and removeAll
+   * <p>For this type there are special operations: add, addAll, remove and removeAll
    * in @UpdateOperation.
    */
   @Documented
@@ -192,11 +156,10 @@ public final class Types {
   public @interface Set {
 
     /**
-		 * Clarification of using the sub-type data type in the collection. It supports
-		 * only simple data type (not Collection, UDT or Tuple)
+     * Clarification of using the sub-type data type in the collection. It supports only simple data
+     * type (not Collection, UDT or Tuple)
      *
-		 * <p>
-		 * In case if you need UDT sub-type in the set, consider @UDTSet annotation
+     * <p>In case if you need UDT sub-type in the set, consider @UDTSet annotation
      *
      * @return data type name of the value
      */
@@ -204,12 +167,10 @@ public final class Types {
   }
 
   /**
-	 * Says to use @DataType.Name.CUSTOM type in schema Java type is @ByteBuffer
-	 * or @byte[]
+   * Says to use @DataType.Name.CUSTOM type in schema Java type is @ByteBuffer or @byte[]
    *
-	 * <p>
-	 * Uses for custom user types that has special implementation. Helenus does not
-	 * deal with this class directly for now, uses only in serialized form.
+   * <p>Uses for custom user types that has special implementation. Helenus does not deal with this
+   * class directly for now, uses only in serialized form.
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -224,53 +185,39 @@ public final class Types {
     String className();
   }
 
-	/**
-	 * Says to use @DataType.Name.TEXT type in schema Java type is @String Using by
-	 * default
-	 */
+  /** Says to use @DataType.Name.TEXT type in schema Java type is @String Using by default */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-	public @interface Text {
-	}
+  public @interface Text {}
 
-	/**
-	 * Says to use @DataType.Name.TIMESTAMP type in schema Java type is @Date Using
-	 * by default
-	 */
+  /** Says to use @DataType.Name.TIMESTAMP type in schema Java type is @Date Using by default */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-	public @interface Timestamp {
-	}
+  public @interface Timestamp {}
 
-	/**
-	 * Says to use @DataType.Name.TIMEUUID type in schema Java type is @UUID
-	 * or @Date
-	 */
+  /** Says to use @DataType.Name.TIMEUUID type in schema Java type is @UUID or @Date */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-	public @interface Timeuuid {
-	}
+  public @interface Timeuuid {}
 
   /**
-	 * Says to use @DataType.Name.TUPLE type in schema Java type is @TupleValue or
-	 * model interface with @Tuple annotation
+   * Says to use @DataType.Name.TUPLE type in schema Java type is @TupleValue or model interface
+   * with @Tuple annotation
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   public @interface Tuple {
 
     /**
-		 * If Java type is the @TupleValue then this field is required. Any Cassandra
-		 * Tuple is the sequence of Cassandra types. For now Helenus supports only
-		 * simple data types in tuples for @TupleValue Java type
+     * If Java type is the @TupleValue then this field is required. Any Cassandra Tuple is the
+     * sequence of Cassandra types. For now Helenus supports only simple data types in tuples
+     * for @TupleValue Java type
      *
-		 * <p>
-		 * In case if Java type is the model interface with @Tuple annotation then all
-		 * methods in this interface can have Types annotations that can be complex
-		 * types as well.
+     * <p>In case if Java type is the model interface with @Tuple annotation then all methods in
+     * this interface can have Types annotations that can be complex types as well.
      *
      * @return data type name sequence
      */
@@ -278,8 +225,8 @@ public final class Types {
   }
 
   /**
-	 * Says to use @DataType.Name.UDT type in schema Java type is @UDTValue or model
-	 * interface with @UDT annotation
+   * Says to use @DataType.Name.UDT type in schema Java type is @UDTValue or model interface
+   * with @UDT annotation
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -287,17 +234,13 @@ public final class Types {
   public @interface UDT {
 
     /**
-		 * If Java type is the @UDTValue then this field is required. Any Cassandra UDT
-		 * has name and must be created before this use as a Cassandra Type.
+     * If Java type is the @UDTValue then this field is required. Any Cassandra UDT has name and
+     * must be created before this use as a Cassandra Type.
      *
-		 * <p>
-		 * This value is the UDT name of the Cassandra Type that was already created in
-		 * the schema
+     * <p>This value is the UDT name of the Cassandra Type that was already created in the schema
      *
-		 * <p>
-		 * In case of Java type is the model interface with @UDT annotation then this
-		 * field is not using since model interface defines UserDefinedType with
-		 * specific name
+     * <p>In case of Java type is the model interface with @UDT annotation then this field is not
+     * using since model interface defines UserDefinedType with specific name
      *
      * @return UDT name
      */
@@ -306,13 +249,10 @@ public final class Types {
     /**
      * Only used for JavaType @UDTValue
      *
-		 * <p>
-		 * In case if value() method returns reserved word that can not be used as a
-		 * name of UDT then forceQuote will add additional quotes around this name in
-		 * all CQL queries.
+     * <p>In case if value() method returns reserved word that can not be used as a name of UDT then
+     * forceQuote will add additional quotes around this name in all CQL queries.
      *
-		 * <p>
-		 * Default value is false.
+     * <p>Default value is false.
      *
      * @return true if quotation is needed
      */
@@ -320,22 +260,16 @@ public final class Types {
   }
 
   /**
-	 * Says to use @DataType.Name.MAP data type in schema with specific UDT sub-type
-	 * as a key and simple sub-type as a value Java type is @Map
+   * Says to use @DataType.Name.MAP data type in schema with specific UDT sub-type as a key and
+   * simple sub-type as a value Java type is @Map
    *
-	 * <p>
-	 * Helenus does not allow to use a specific implementation of the collection
-	 * thereof data retrieval operation result can be a collection with another
-	 * implementation.
+   * <p>Helenus does not allow to use a specific implementation of the collection thereof data
+   * retrieval operation result can be a collection with another implementation.
    *
-	 * <p>
-	 * This annotation is usually used only for sub-types clarification and only in
-	 * case if sub-type is Java type that corresponds to multiple Cassandra data
-	 * types.
+   * <p>This annotation is usually used only for sub-types clarification and only in case if
+   * sub-type is Java type that corresponds to multiple Cassandra data types.
    *
-	 * <p>
-	 * For this type there are special operations: put and putAll
-	 * in @UpdateOperation.
+   * <p>For this type there are special operations: put and putAll in @UpdateOperation.
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -350,12 +284,10 @@ public final class Types {
     UDT key();
 
     /**
-		 * Clarification of using the sub-type data type in the collection. It supports
-		 * only simple data type (not Collection, UDT or Tuple)
+     * Clarification of using the sub-type data type in the collection. It supports only simple data
+     * type (not Collection, UDT or Tuple)
      *
-		 * <p>
-		 * In case if you need UDT value sub-type in the map, consider @UDTMap
-		 * annotations
+     * <p>In case if you need UDT value sub-type in the map, consider @UDTMap annotations
      *
      * @return data type name of the value
      */
@@ -363,22 +295,17 @@ public final class Types {
   }
 
   /**
-	 * Says to use @DataType.Name.LIST data type in schema with specific UDT
-	 * sub-type Java type is @List
+   * Says to use @DataType.Name.LIST data type in schema with specific UDT sub-type Java type
+   * is @List
    *
-	 * <p>
-	 * Helenus does not allow to use a specific implementation of the collection
-	 * thereof data retrieval operation result can be a collection with another
-	 * implementation.
+   * <p>Helenus does not allow to use a specific implementation of the collection thereof data
+   * retrieval operation result can be a collection with another implementation.
    *
-	 * <p>
-	 * This annotation is usually used only for sub-types clarification and only in
-	 * case if sub-type is Java type that corresponds to multiple Cassandra data
-	 * types.
+   * <p>This annotation is usually used only for sub-types clarification and only in case if
+   * sub-type is Java type that corresponds to multiple Cassandra data types.
    *
-	 * <p>
-	 * For this type there are special operations: prepend, prependAll, setIdx,
-	 * append, appendAll, discard and discardAll in @UpdateOperation
+   * <p>For this type there are special operations: prepend, prependAll, setIdx, append, appendAll,
+   * discard and discardAll in @UpdateOperation
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -394,22 +321,16 @@ public final class Types {
   }
 
   /**
-	 * Says to use @DataType.Name.MAP data type in schema with specific UDT
-	 * sub-types Java type is @Map
+   * Says to use @DataType.Name.MAP data type in schema with specific UDT sub-types Java type
+   * is @Map
    *
-	 * <p>
-	 * Helenus does not allow to use a specific implementation of the collection
-	 * thereof data retrieval operation result can be a collection with another
-	 * implementation.
+   * <p>Helenus does not allow to use a specific implementation of the collection thereof data
+   * retrieval operation result can be a collection with another implementation.
    *
-	 * <p>
-	 * This annotation is usually used only for sub-types clarification and only in
-	 * case if sub-type is Java type that corresponds to multiple Cassandra data
-	 * types.
+   * <p>This annotation is usually used only for sub-types clarification and only in case if
+   * sub-type is Java type that corresponds to multiple Cassandra data types.
    *
-	 * <p>
-	 * For this type there are special operations: put and putAll
-	 * in @UpdateOperation.
+   * <p>For this type there are special operations: put and putAll in @UpdateOperation.
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -424,8 +345,7 @@ public final class Types {
     UDT key();
 
     /**
-		 * Clarification of using the UDT data type as a value sub-type in the
-		 * collection.
+     * Clarification of using the UDT data type as a value sub-type in the collection.
      *
      * @return annotation of the UDT value
      */
@@ -433,21 +353,15 @@ public final class Types {
   }
 
   /**
-	 * Says to use @DataType.Name.SET data type in schema with specific UDT sub-type
-	 * Java type is @Set
+   * Says to use @DataType.Name.SET data type in schema with specific UDT sub-type Java type is @Set
    *
-	 * <p>
-	 * Helenus does not allow to use a specific implementation of the collection
-	 * thereof data retrieval operation result can be a collection with another
-	 * implementation.
+   * <p>Helenus does not allow to use a specific implementation of the collection thereof data
+   * retrieval operation result can be a collection with another implementation.
    *
-	 * <p>
-	 * This annotation is usually used only for sub-types clarification and only in
-	 * case if sub-type is Java type that corresponds to multiple Cassandra data
-	 * types.
+   * <p>This annotation is usually used only for sub-types clarification and only in case if
+   * sub-type is Java type that corresponds to multiple Cassandra data types.
    *
-	 * <p>
-	 * For this type there are special operations: add, addAll, remove and removeAll
+   * <p>For this type there are special operations: add, addAll, remove and removeAll
    * in @UpdateOperation.
    */
   @Documented
@@ -464,22 +378,16 @@ public final class Types {
   }
 
   /**
-	 * Says to use @DataType.Name.MAP data type in schema with specific simple
-	 * sub-type as a key and UDT sub-type as a value Java type is @Map
+   * Says to use @DataType.Name.MAP data type in schema with specific simple sub-type as a key and
+   * UDT sub-type as a value Java type is @Map
    *
-	 * <p>
-	 * Helenus does not allow to use a specific implementation of the collection
-	 * thereof data retrieval operation result can be a collection with another
-	 * implementation.
+   * <p>Helenus does not allow to use a specific implementation of the collection thereof data
+   * retrieval operation result can be a collection with another implementation.
    *
-	 * <p>
-	 * This annotation is usually used only for sub-types clarification and only in
-	 * case if sub-type is Java type that corresponds to multiple Cassandra data
-	 * types.
+   * <p>This annotation is usually used only for sub-types clarification and only in case if
+   * sub-type is Java type that corresponds to multiple Cassandra data types.
    *
-	 * <p>
-	 * For this type there are special operations: put and putAll
-	 * in @UpdateOperation.
+   * <p>For this type there are special operations: put and putAll in @UpdateOperation.
    */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
@@ -487,39 +395,32 @@ public final class Types {
   public @interface UDTValueMap {
 
     /**
-		 * Clarification of using the sub-type data type in the collection. It supports
-		 * only simple data type (not Collection, UDT or Tuple)
+     * Clarification of using the sub-type data type in the collection. It supports only simple data
+     * type (not Collection, UDT or Tuple)
      *
-		 * <p>
-		 * In case if you need UDT key sub-type in the map, consider @UDTMap annotations
+     * <p>In case if you need UDT key sub-type in the map, consider @UDTMap annotations
      *
      * @return data type name of the key
      */
     DataType.Name key();
 
     /**
-		 * Clarification of using the UDT data type as a value sub-type in the
-		 * collection.
+     * Clarification of using the UDT data type as a value sub-type in the collection.
      *
      * @return annotation of the UDT value
      */
     UDT value();
   }
 
-	/**
-	 * Says to use @DataType.Name.UUID type in schema Java type is @UUID Using by
-	 * default
-	 */
+  /** Says to use @DataType.Name.UUID type in schema Java type is @UUID Using by default */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-	public @interface Uuid {
-	}
+  public @interface Uuid {}
 
   /** Says to use @DataType.Name.VARCHAR type in schema Java type is @String */
   @Documented
   @Retention(RetentionPolicy.RUNTIME)
   @Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
-	public @interface Varchar {
-	}
+  public @interface Varchar {}
 }

src/main/java/net/helenus/mapping/annotation/UDT.java

@@ -39,11 +39,10 @@ public @interface UDT {
   String value() default "";
 
   /**
-	 * For reserved words in Cassandra we need quotation in CQL queries. This
-	 * property marks that the name of the UDT type needs to be quoted.
+   * For reserved words in Cassandra we need quotation in CQL queries. This property marks that the
+   * name of the UDT type needs to be quoted.
    *
-	 * <p>
-	 * Default value is false, we are quoting only selected names.
+   * <p>Default value is false, we are quoting only selected names.
    *
    * @return true if name have to be quoted
    */

src/main/java/net/helenus/mapping/convert/AbstractEntityValueWriter.java

@@ -16,7 +16,6 @@
 package net.helenus.mapping.convert;
 
 import java.util.Map;
-
 import net.helenus.core.Helenus;
 import net.helenus.core.reflect.MapExportable;
 import net.helenus.mapping.HelenusEntity;

src/main/java/net/helenus/mapping/convert/CamelCaseToUnderscoreConverter.java

@@ -15,9 +15,8 @@
  */
 package net.helenus.mapping.convert;
 
-import java.util.function.Function;
-
 import com.google.common.base.CaseFormat;
+import java.util.function.Function;
 
 public enum CamelCaseToUnderscoreConverter implements Function<String, String> {
   INSTANCE;

src/main/java/net/helenus/mapping/convert/DateToTimeuuidConverter.java

@@ -18,7 +18,6 @@ package net.helenus.mapping.convert;
 import java.util.Date;
 import java.util.UUID;
 import java.util.function.Function;
-
 import net.helenus.support.Timeuuid;
 
 /** Simple Date to TimeUUID Converter */

src/main/java/net/helenus/mapping/convert/ProxyValueReader.java

@@ -17,7 +17,6 @@ package net.helenus.mapping.convert;
 
 import java.util.Map;
 import java.util.function.Function;
-
 import net.helenus.core.Helenus;
 import net.helenus.mapping.HelenusEntity;
 import net.helenus.mapping.value.ColumnValueProvider;