greg/helenus
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

formatting

Browse source
This commit is contained in:
Greg Burd 2017-08-17 10:10:38 -04:00
parent 602e3521b4
commit 6ad99fc459
245 changed files with 11567 additions and 11917 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
src/main/java/com/datastax/driver/core/DefaultMetadata.java
View file

@ -5,7 +5,9 @@ import java.util.List;
public class DefaultMetadata extends Metadata {
public DefaultMetadata() { super(null); }
public DefaultMetadata() {
super(null);
}
private DefaultMetadata(Cluster.Manager cluster) {
super(cluster);
@ -18,5 +20,4 @@ public class DefaultMetadata extends Metadata {
public TupleType newTupleType(List<DataType> types) {
return new TupleType(types, ProtocolVersion.NEWEST_SUPPORTED, CodecRegistry.DEFAULT_INSTANCE);
}
}

47
src/main/java/com/datastax/driver/core/schemabuilder/CreateCustomIndex.java
View file

@ -1,11 +1,11 @@
package com.datastax.driver.core.schemabuilder;
import com.google.common.base.Optional;
import static com.datastax.driver.core.schemabuilder.SchemaStatement.STATEMENT_START;
import static com.datastax.driver.core.schemabuilder.SchemaStatement.validateNotEmpty;
import static com.datastax.driver.core.schemabuilder.SchemaStatement.validateNotKeyWord;
import com.google.common.base.Optional;
public class CreateCustomIndex extends CreateIndex {
private String indexName;
@ -18,7 +18,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;
}
@ -42,8 +45,15 @@ public class CreateCustomIndex extends CreateIndex {
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();
@ -57,7 +67,10 @@ public class CreateCustomIndex extends CreateIndex {
*/
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();
}
@ -71,7 +84,10 @@ public class CreateCustomIndex extends CreateIndex {
*/
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());
}
@ -84,19 +100,28 @@ public class CreateCustomIndex extends CreateIndex {
*/
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());
}
}
String getCustomClassName() { return ""; }
String getOptions() { return ""; }
String getCustomClassName() {
return "";
}
String getOptions() {
return "";
}
@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 ");

4
src/main/java/com/datastax/driver/core/schemabuilder/CreateTable.java
View file

@ -17,9 +17,7 @@ package com.datastax.driver.core.schemabuilder;
import com.datastax.driver.core.CodecRegistry;
/**
* A built CREATE TABLE statement.
*/
/** A built CREATE TABLE statement. */
public class CreateTable extends Create {
public CreateTable(String keyspaceName, String tableName) {

2
src/main/java/net/helenus/config/DefaultHelenusSettings.java
View file

@ -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;
@ -45,5 +44,4 @@ public class DefaultHelenusSettings implements HelenusSettings {
public MapperInstantiator getMapperInstantiator() {
return ReflectionMapperInstantiator.INSTANCE;
}
}

6
src/main/java/net/helenus/config/GetterMethodDetector.java
View file

@ -15,13 +15,11 @@
*/
package net.helenus.config;
import net.helenus.mapping.annotation.Transient;
import java.lang.reflect.Method;
import java.util.function.Function;
import net.helenus.mapping.annotation.Transient;
public enum GetterMethodDetector implements Function<Method, Boolean> {
INSTANCE;
@Override
@ -41,7 +39,5 @@ public enum GetterMethodDetector implements Function<Method, Boolean> {
}
return true;
}
}

2
src/main/java/net/helenus/config/HelenusSettings.java
View file

@ -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;
@ -30,5 +29,4 @@ public interface HelenusSettings {
DslInstantiator getDslInstantiator();
MapperInstantiator getMapperInstantiator();
}

47
src/main/java/net/helenus/core/AbstractSessionOperations.java
View file

@ -15,48 +15,41 @@
*/
package net.helenus.core;
import java.io.PrintStream;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;
import brave.Tracer;
import com.codahale.metrics.MetricRegistry;
import com.datastax.driver.core.schemabuilder.SchemaStatement;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.datastax.driver.core.*;
import com.datastax.driver.core.querybuilder.BuiltStatement;
import com.google.common.util.concurrent.ListenableFuture;
import java.io.PrintStream;
import java.util.concurrent.Executor;
import net.helenus.mapping.value.ColumnValuePreparer;
import net.helenus.mapping.value.ColumnValueProvider;
import net.helenus.support.HelenusException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.xml.validation.Schema;
public abstract class AbstractSessionOperations {
final Logger logger = LoggerFactory.getLogger(getClass());
abstract public Session currentSession();
public abstract Session currentSession();
abstract public String usingKeyspace();
public abstract String usingKeyspace();
abstract public boolean isShowCql();
public abstract boolean isShowCql();
abstract public PrintStream getPrintStream();
public abstract PrintStream getPrintStream();
abstract public Executor getExecutor();
public abstract Executor getExecutor();
abstract public SessionRepository getSessionRepository();
public abstract SessionRepository getSessionRepository();
abstract public ColumnValueProvider getValueProvider();
public abstract ColumnValueProvider getValueProvider();
abstract public ColumnValuePreparer getValuePreparer();
abstract public ConsistencyLevel getDefaultConsistencyLevel();
public abstract ColumnValuePreparer getValuePreparer();
public abstract ConsistencyLevel getDefaultConsistencyLevel();
public PreparedStatement prepare(RegularStatement statement) {
try {
@ -111,13 +104,16 @@ public abstract class AbstractSessionOperations {
}
}
public Tracer getZipkinTracer() { return null; }
public MetricRegistry getMetricRegistry() { return null; }
public void cache(String key, Object value) {
public Tracer getZipkinTracer() {
return null;
}
public MetricRegistry getMetricRegistry() {
return null;
}
public void cache(String key, Object value) {}
RuntimeException translateException(RuntimeException e) {
if (e instanceof HelenusException) {
return e;
@ -128,5 +124,4 @@ public abstract class AbstractSessionOperations {
void printCql(String cql) {
getPrintStream().println(cql);
}
}

5
src/main/java/net/helenus/core/AutoDdl.java
View file

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

1
src/main/java/net/helenus/core/ConflictingUnitOfWorkException.java
View file

@ -7,5 +7,4 @@ public class ConflictingUnitOfWorkException extends Exception {
ConflictingUnitOfWorkException(UnitOfWork uow) {
this.uow = uow;
}
}

10
src/main/java/net/helenus/core/DslInstantiator.java
View file

@ -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);
}

8
src/main/java/net/helenus/core/Filter.java
View file

@ -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;
@ -95,7 +93,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);
@ -109,5 +108,4 @@ public final class Filter<V> {
public String toString() {
return node.getColumnName() + postulate.toString();
}
}

1
src/main/java/net/helenus/core/Getter.java
View file

@ -18,5 +18,4 @@ package net.helenus.core;
public interface Getter<V> {
V get();
}

29
src/main/java/net/helenus/core/Helenus.java
View file

@ -15,14 +15,12 @@
*/
package net.helenus.core;
import java.util.*;
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 java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import net.helenus.config.DefaultHelenusSettings;
import net.helenus.config.HelenusSettings;
import net.helenus.core.reflect.DslExportable;
@ -33,14 +31,14 @@ import net.helenus.support.HelenusMappingException;
public final class Helenus {
private static volatile HelenusSettings settings = new DefaultHelenusSettings();
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 HelenusSession singleton;
private Helenus() {
}
private Helenus() {}
protected static void setSession(HelenusSession session) {
sessions.add(session);
@ -52,7 +50,8 @@ public final class Helenus {
}
public static void shutdown() {
sessions.forEach((session) -> {
sessions.forEach(
(session) -> {
session.close();
sessions.remove(session);
});
@ -104,7 +103,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;
@ -123,7 +125,6 @@ public final class Helenus {
if (c != null) {
instance = c;
}
}
}
@ -178,10 +179,8 @@ public final class Helenus {
metadataForEntity.putIfAbsent(iface, metadata);
return entity(iface, metadata);
}
throw new HelenusMappingException("unknown dsl object or mapping interface " + ifaceOrDsl);
}
}

179
src/main/java/net/helenus/core/HelenusSession.java
View file

@ -15,6 +15,12 @@
*/
package net.helenus.core;
import brave.Tracer;
import com.codahale.metrics.MetricRegistry;
import com.datastax.driver.core.*;
import com.diffplug.common.base.Errors;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import java.io.Closeable;
import java.io.PrintStream;
import java.util.Map;
@ -23,14 +29,6 @@ import java.util.Set;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import brave.Tracer;
import com.codahale.metrics.MetricRegistry;
import com.datastax.driver.core.*;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.diffplug.common.base.Errors;
import net.helenus.core.operation.*;
import net.helenus.core.reflect.Drafted;
import net.helenus.core.reflect.HelenusPropertyNode;
@ -65,14 +63,23 @@ public final class HelenusSession extends AbstractSessionOperations implements C
private final Cache<String, Object> sessionCache;
private UnitOfWork currentUnitOfWork;
HelenusSession(Session session, String usingKeyspace, CodecRegistry registry, boolean showCql,
PrintStream printStream, SessionRepositoryBuilder sessionRepositoryBuilder, Executor executor,
boolean dropSchemaOnClose, ConsistencyLevel consistencyLevel, MetricRegistry metricRegistry,
HelenusSession(
Session session,
String usingKeyspace,
CodecRegistry registry,
boolean showCql,
PrintStream printStream,
SessionRepositoryBuilder sessionRepositoryBuilder,
Executor executor,
boolean dropSchemaOnClose,
ConsistencyLevel consistencyLevel,
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();
@ -85,12 +92,15 @@ public final class HelenusSession extends AbstractSessionOperations implements C
this.valueProvider = new RowColumnValueProvider(this.sessionRepository);
this.valuePreparer = new StatementColumnValuePreparer(this.sessionRepository);
this.metadata = session.getCluster().getMetadata();
this.sessionCache = CacheBuilder.newBuilder().maximumSize(MAX_CACHE_SIZE)
.expireAfterAccess(MAX_CACHE_EXPIRE_SECONDS, TimeUnit.SECONDS).recordStats().build();
this.sessionCache =
CacheBuilder.newBuilder()
.maximumSize(MAX_CACHE_SIZE)
.expireAfterAccess(MAX_CACHE_EXPIRE_SECONDS, TimeUnit.SECONDS)
.recordStats()
.build();
this.currentUnitOfWork = null;
}
@Override
public Session currentSession() {
return session;
@ -148,16 +158,22 @@ public final class HelenusSession extends AbstractSessionOperations implements C
}
@Override
public Tracer getZipkinTracer() { return zipkinTracer; }
public Tracer getZipkinTracer() {
return zipkinTracer;
}
@Override
public MetricRegistry getMetricRegistry() { return metricRegistry; }
public MetricRegistry getMetricRegistry() {
return metricRegistry;
}
public ConsistencyLevel getDefaultConsistencyLevel() {
return defaultConsistencyLevel;
}
public Metadata getMetadata() { return metadata; }
public Metadata getMetadata() {
return metadata;
}
public synchronized UnitOfWork begin() {
if (currentUnitOfWork == null) {
@ -194,11 +210,12 @@ public final class HelenusSession extends AbstractSessionOperations implements C
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);
});
}
@ -221,7 +238,8 @@ public final class HelenusSession extends AbstractSessionOperations implements C
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) {
@ -230,12 +248,12 @@ public final class HelenusSession extends AbstractSessionOperations implements C
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");
@ -243,12 +261,12 @@ public final class HelenusSession extends AbstractSessionOperations implements C
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");
@ -258,12 +276,21 @@ public final class HelenusSession extends AbstractSessionOperations implements C
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");
@ -275,12 +302,23 @@ public final class HelenusSession extends AbstractSessionOperations implements C
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");
@ -294,14 +332,26 @@ public final class HelenusSession extends AbstractSessionOperations implements C
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");
@ -317,9 +367,17 @@ public final class HelenusSession extends AbstractSessionOperations implements C
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() {
@ -344,11 +402,17 @@ public final class HelenusSession extends AbstractSessionOperations implements C
return new UpdateOperation(this, p, v);
}
public <T> InsertOperation<T> insert() { return new InsertOperation<T>(this, true); }
public <T> InsertOperation<T> insert() {
return new InsertOperation<T>(this, true);
}
public <T> InsertOperation<T> insert(Object pojo) { return this.<T>insert(pojo, null); }
public <T> InsertOperation<T> insert(Object pojo) {
return this.<T>insert(pojo, null);
}
public <T> InsertOperation<T> insert(Drafted draft) { return this.<T>insert(draft.build(), draft.mutated()); }
public <T> InsertOperation<T> insert(Drafted draft) {
return this.<T>insert(draft.build(), draft.mutated());
}
public <T> InsertOperation<T> insert(Object pojo, Set<String> mutations) {
Objects.requireNonNull(pojo, "pojo is empty");
@ -363,9 +427,13 @@ public final class HelenusSession extends AbstractSessionOperations implements C
return new InsertOperation<T>(this, false);
}
public <T> InsertOperation<T> upsert(Drafted draft) { return this.<T>upsert(draft.build(), draft.mutated()); }
public <T> InsertOperation<T> upsert(Drafted draft) {
return this.<T>upsert(draft.build(), draft.mutated());
}
public <T> InsertOperation<T> upsert(Object pojo) { return this.<T>upsert(pojo, null); }
public <T> InsertOperation<T> upsert(Object pojo) {
return this.<T>upsert(pojo, null);
}
public <T> InsertOperation<T> upsert(Object pojo, Set<String> mutations) {
Objects.requireNonNull(pojo, "pojo is empty");
@ -418,13 +486,11 @@ public final class HelenusSession extends AbstractSessionOperations implements C
private void dropSchema() {
sessionRepository.entities().forEach(e -> dropEntity(e));
}
private void dropEntity(HelenusEntity entity) {
switch (entity.getType()) {
case TABLE:
execute(SchemaUtil.dropTable(entity), true);
break;
@ -432,9 +498,6 @@ public final class HelenusSession extends AbstractSessionOperations implements C
case UDT:
execute(SchemaUtil.dropUserType(entity), true);
break;
}
}
}

8
src/main/java/net/helenus/core/HelenusValidator.java
View file

@ -16,15 +16,12 @@
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;
public enum HelenusValidator implements PropertyValueValidator {
INSTANCE;
public void validate(HelenusProperty prop, Object value) {
@ -38,14 +35,13 @@ 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) {
throw new HelenusException("wrong value '" + value + "' for " + prop);
}
}
}
}

1
src/main/java/net/helenus/core/MapperInstantiator.java
View file

@ -20,5 +20,4 @@ import java.util.Map;
public interface MapperInstantiator {
<E> E instantiate(Class<E> iface, Map<String, Object> src, ClassLoader classLoader);
}

111
src/main/java/net/helenus/core/Mappers.java
View file

@ -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,10 +24,9 @@ import net.helenus.support.Fun;
public final class Mappers {
private Mappers() {
}
private Mappers() {}
public final static class Mapper1<A> implements Function<Row, Fun.Tuple1<A>> {
public static final class Mapper1<A> implements Function<Row, Fun.Tuple1<A>> {
private final ColumnValueProvider provider;
private final HelenusProperty p1;
@ -45,7 +42,7 @@ public final class Mappers {
}
}
public final static class Mapper2<A, B> implements Function<Row, Fun.Tuple2<A, B>> {
public static final class Mapper2<A, B> implements Function<Row, Fun.Tuple2<A, B>> {
private final ColumnValueProvider provider;
private final HelenusProperty p1;
@ -59,18 +56,22 @@ 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));
}
}
public final static class Mapper3<A, B, C> implements Function<Row, Fun.Tuple3<A, B, C>> {
public static final class Mapper3<A, B, C> implements Function<Row, Fun.Tuple3<A, B, C>> {
private final ColumnValueProvider provider;
private final HelenusProperty p1;
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,12 +81,14 @@ 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));
}
}
public final static class Mapper4<A, B, C, D> implements Function<Row, Fun.Tuple4<A, B, C, D>> {
public static final class Mapper4<A, B, C, D> implements Function<Row, Fun.Tuple4<A, B, C, D>> {
private final ColumnValueProvider provider;
private final HelenusProperty p1;
@ -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 final static 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 final static 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 final static 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,11 +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));
}
}
}

4
src/main/java/net/helenus/core/Operator.java
View file

@ -19,7 +19,6 @@ import java.util.HashMap;
import java.util.Map;
public enum Operator {
EQ("=="),
IN("in"),
@ -34,7 +33,7 @@ public enum Operator {
private final String name;
private final static Map<String, Operator> indexByName = new HashMap<String, Operator>();
private static final Map<String, Operator> indexByName = new HashMap<String, Operator>();
static {
for (Operator fo : Operator.values()) {
@ -53,5 +52,4 @@ public enum Operator {
public static Operator findByOperator(String name) {
return indexByName.get(name);
}
}

7
src/main/java/net/helenus/core/Ordered.java
View file

@ -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,16 +32,13 @@ public final class Ordered {
}
switch (direction) {
case ASC:
return QueryBuilder.asc(propNode.getColumnName());
case DESC:
return QueryBuilder.desc(propNode.getColumnName());
}
throw new HelenusMappingException("invalid direction " + direction);
}
}

26
src/main/java/net/helenus/core/Postulate.java
View file

@ -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,10 +38,9 @@ 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()));
return QueryBuilder.eq(
node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
case IN:
Object[] preparedValues = new Object[values.length];
@ -52,25 +50,24 @@ public final class Postulate<V> {
return QueryBuilder.in(node.getColumnName(), preparedValues);
case LT:
return QueryBuilder.lt(node.getColumnName(),
valuePreparer.prepareColumnValue(values[0], node.getProperty()));
return QueryBuilder.lt(
node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
case LTE:
return QueryBuilder.lte(node.getColumnName(),
valuePreparer.prepareColumnValue(values[0], node.getProperty()));
return QueryBuilder.lte(
node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
case GT:
return QueryBuilder.gt(node.getColumnName(),
valuePreparer.prepareColumnValue(values[0], node.getProperty()));
return QueryBuilder.gt(
node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
case GTE:
return QueryBuilder.gte(node.getColumnName(),
valuePreparer.prepareColumnValue(values[0], node.getProperty()));
return QueryBuilder.gte(
node.getColumnName(), valuePreparer.prepareColumnValue(values[0], node.getProperty()));
default:
throw new HelenusMappingException("unknown filter operation " + operator);
}
}
@Override
@ -92,11 +89,8 @@ public final class Postulate<V> {
b.append(String.valueOf(values[i]));
}
return b.append(')').toString();
}
return operator.getName() + values[0];
}
}

1
src/main/java/net/helenus/core/PropertyValueValidator.java
View file

@ -20,5 +20,4 @@ import net.helenus.mapping.HelenusProperty;
public interface PropertyValueValidator {
void validate(HelenusProperty prop, Object value);
}

18
src/main/java/net/helenus/core/Query.java
View file

@ -15,24 +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
*
*/
/** Sugar methods for the queries */
public final class Query {
private Query() {
}
private Query() {}
public static BindMarker marker() {
return QueryBuilder.bindMarker();
@ -83,7 +76,6 @@ public final class Query {
public V get() {
return listGetter.get().get(index);
}
};
}
@ -97,8 +89,6 @@ public final class Query {
public V get() {
return mapGetter.get().get(k);
}
};
}
}

109
src/main/java/net/helenus/core/SchemaUtil.java
View file

@ -15,14 +15,12 @@
*/
package net.helenus.core;
import java.util.*;
import java.util.stream.Collectors;
import com.datastax.driver.core.*;
import com.datastax.driver.core.IndexMetadata;
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.mapping.*;
import net.helenus.mapping.ColumnType;
import net.helenus.mapping.type.OptionalColumnMetadata;
@ -31,8 +29,7 @@ import net.helenus.support.HelenusMappingException;
public final class SchemaUtil {
private SchemaUtil() {
}
private SchemaUtil() {}
public static RegularStatement use(String keyspace, boolean forceQuote) {
if (forceQuote) {
@ -55,23 +52,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);
@ -80,13 +85,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()) {
@ -103,13 +108,13 @@ 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);
}
}
if (dropUnusedColumns) {
@ -117,13 +122,11 @@ public final class SchemaUtil {
if (!visitedColumns.contains(field)) {
result.add(alter.dropColumn(field));
}
}
}
return result;
}
public static SchemaStatement dropUserType(HelenusEntity entity) {
@ -133,7 +136,6 @@ public final class SchemaUtil {
}
return SchemaBuilder.dropType(entity.getName().toCql()).ifExists();
}
public static SchemaStatement dropUserType(UserType type) {
@ -166,20 +168,19 @@ public final class SchemaUtil {
}
prop.getDataType().addColumn(create, prop.getColumnName());
}
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);
@ -189,7 +190,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()) {
@ -206,13 +208,12 @@ 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);
}
}
if (dropUnusedColumns) {
@ -220,7 +221,6 @@ public final class SchemaUtil {
if (!visitedColumns.contains(cm.getName())) {
result.add(alter.dropColumn(cm.getName()));
}
}
}
@ -235,7 +235,6 @@ public final class SchemaUtil {
}
return SchemaBuilder.dropTable(entity.getName().toCql()).ifExists();
}
public static SchemaStatement createIndex(HelenusProperty prop) {
@ -254,20 +253,28 @@ public final class SchemaUtil {
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();
entity.getOrderedProperties().stream().filter(p -> p.getIndexName().isPresent()).forEach(p -> {
final Set<String> visitedColumns =
dropUnusedIndexes ? new HashSet<String>() : Collections.<String>emptySet();
entity
.getOrderedProperties()
.stream()
.filter(p -> p.getIndexName().isPresent())
.forEach(
p -> {
String columnName = p.getColumnName().getName();
if (dropUnusedIndexes) {
@ -284,21 +291,20 @@ public final class SchemaUtil {
} else {
list.add(createIndex(p));
}
});
if (dropUnusedIndexes) {
tmd.getColumns().stream().filter(c -> tmd.getIndex(c.getName()) != null && !visitedColumns.contains(c.getName()))
.forEach(c -> {
tmd.getColumns()
.stream()
.filter(c -> tmd.getIndex(c.getName()) != null && !visitedColumns.contains(c.getName()))
.forEach(
c -> {
list.add(SchemaBuilder.dropIndex(tmd.getIndex(c.getName()).getName()).ifExists());
});
}
return list;
}
public static SchemaStatement dropIndex(HelenusProperty prop) {
@ -319,9 +325,11 @@ 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());
}
private static OptionalColumnMetadata optional(final ColumnMetadata columnMetadata) {
@ -337,7 +345,6 @@ public final class SchemaUtil {
public DataType getType() {
return columnMetadata.getType();
}
};
}
return null;
@ -356,10 +363,8 @@ public final class SchemaUtil {
public DataType getType() {
return dataType;
}
};
}
return null;
}
}

95
src/main/java/net/helenus/core/SessionInitializer.java
View file

@ -15,24 +15,22 @@
*/
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 net.helenus.mapping.HelenusEntity;
import net.helenus.mapping.HelenusEntityType;
import net.helenus.mapping.value.ColumnValuePreparer;
import net.helenus.mapping.value.ColumnValueProvider;
import net.helenus.support.HelenusException;
import net.helenus.support.PackageUtil;
import brave.Tracer;
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 net.helenus.mapping.HelenusEntity;
import net.helenus.mapping.HelenusEntityType;
import net.helenus.mapping.value.ColumnValuePreparer;
import net.helenus.mapping.value.ColumnValueProvider;
import net.helenus.support.HelenusException;
import net.helenus.support.PackageUtil;
public final class SessionInitializer extends AbstractSessionOperations {
@ -164,10 +162,11 @@ public final class SessionInitializer extends AbstractSessionOperations {
public SessionInitializer addPackage(String packageName) {
try {
PackageUtil.getClasses(packageName).stream().filter(c -> c.isInterface() && !c.isAnnotation())
PackageUtil.getClasses(packageName)
.stream()
.filter(c -> c.isInterface() && !c.isAnnotation())
.forEach(initList::add);
}
catch (IOException | ClassNotFoundException e) {
} catch (IOException | ClassNotFoundException e) {
throw new HelenusException("fail to add package " + packageName, e);
}
return this;
@ -227,8 +226,18 @@ 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, metricRegistry, zipkinTracer);
return new HelenusSession(
session,
usingKeyspace,
registry,
showCql,
printStream,
sessionRepository,
executor,
autoDdl == AutoDdl.CREATE_DROP,
consistencyLevel,
metricRegistry,
zipkinTracer);
}
private void initialize() {
@ -241,42 +250,49 @@ public final class SessionInitializer extends AbstractSessionOperations {
UserTypeOperations userTypeOps = new UserTypeOperations(this, dropUnusedColumns);
switch (autoDdl) {
case CREATE_DROP:
// Drop tables first, 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:
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));
break;
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:
eachUserTypeInOrder(userTypeOps, e -> userTypeOps.updateUserType(getUserType(e), 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));
break;
}
KeyspaceMetadata km = getKeyspaceMetadata();
@ -284,25 +300,33 @@ public final class SessionInitializer extends AbstractSessionOperations {
for (UserType userType : km.getUserTypes()) {
sessionRepository.addUserType(userType.getTypeName(), userType);
}
}
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);
});
/*
@ -320,8 +344,12 @@ public final class SessionInitializer extends AbstractSessionOperations {
*/
}
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);
@ -338,19 +366,18 @@ public final class SessionInitializer extends AbstractSessionOperations {
action.accept(e);
processedSet.add(e);
}
}
private KeyspaceMetadata getKeyspaceMetadata() {
if (keyspaceMetadata == null) {
keyspaceMetadata = session.getCluster().getMetadata().getKeyspace(usingKeyspace.toLowerCase());
keyspaceMetadata =
session.getCluster().getMetadata().getKeyspace(usingKeyspace.toLowerCase());
}
return keyspaceMetadata;
}
private TableMetadata getTableMetadata(HelenusEntity entity) {
return getKeyspaceMetadata().getTable(entity.getName().getName());
}
private UserType getUserType(HelenusEntity entity) {

8
src/main/java/net/helenus/core/SessionRepository.java
View file

@ -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) {
@ -42,5 +41,4 @@ public final class SessionRepository {
public Collection<HelenusEntity> entities() {
return entityMap.values();
}
}

24
src/main/java/net/helenus/core/SessionRepositoryBuilder.java
View file

@ -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>();
@ -45,7 +44,6 @@ public final class SessionRepositoryBuilder {
private final Session session;
SessionRepositoryBuilder(Session session) {
this.session = session;
}
@ -85,7 +83,6 @@ public final class SessionRepositoryBuilder {
if (concurrentEntity == null) {
addUserDefinedTypes(entity.getOrderedProperties());
}
}
public HelenusEntity add(Object dsl, Optional<HelenusEntityType> type) {
@ -101,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);
@ -111,7 +109,6 @@ public final class SessionRepositoryBuilder {
} else {
entity = concurrentEntity;
}
}
return entity;
@ -140,13 +137,8 @@ public final class SessionRepositoryBuilder {
if (HelenusEntityType.UDT == prop.getEntity().getType()) {
userTypeUsesMap.put(prop.getEntity(), addedUserType);
}
}
}
}
}
}

19
src/main/java/net/helenus/core/TableOperations.java
View file

@ -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;
@ -40,13 +39,11 @@ public final class TableOperations {
sessionOps.execute(SchemaUtil.createTable(entity), true);
executeBatch(SchemaUtil.createIndexes(entity));
}
public void dropTable(HelenusEntity entity) {
sessionOps.execute(SchemaUtil.dropTable(entity), true);
}
public void validateTable(TableMetadata tmd, HelenusEntity entity) {
@ -62,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);
}
}
@ -79,10 +79,9 @@ public final class TableOperations {
private void executeBatch(List<SchemaStatement> list) {
list.forEach(s -> {
list.forEach(
s -> {
sessionOps.execute(s, true);
});
}
}

18
src/main/java/net/helenus/core/UnitOfWork.java
View file

@ -1,13 +1,10 @@
package net.helenus.core;
import com.diffplug.common.base.Errors;
import java.util.ArrayList;
import java.util.function.Function;
/**
* Encapsulates the concept of a "transaction" as a unit-of-work.
*/
/** Encapsulates the concept of a "transaction" as a unit-of-work. */
public class UnitOfWork {
private final HelenusSession session;
@ -19,8 +16,8 @@ public class UnitOfWork {
}
/**
* Marks the beginning of a transactional section of work. Will write a record
* to the shared write-ahead log.
* Marks the beginning of a transactional section of work. Will write a record to the shared
* write-ahead log.
*
* @return the handle used to commit or abort the work.
*/
@ -34,8 +31,7 @@ public class UnitOfWork {
}
/**
* 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 ConflictingUnitOfWorkException when the work overlaps with other concurrent writers.
@ -51,9 +47,7 @@ public class UnitOfWork {
return Function.<Void>identity();
}
/**
* Explicitly discard the work and mark it as as such in the log.
*/
/** Explicitly discard the work and mark it as as such in the log. */
public void abort() {
// log.record(txn::abort)
// cache.invalidateSince(txn::start time)
@ -62,6 +56,4 @@ public class UnitOfWork {
public String describeConflicts() {
return "it's complex...";
}
}

18
src/main/java/net/helenus/core/UserTypeOperations.java
View file

@ -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;
@ -36,13 +34,11 @@ public final class UserTypeOperations {
public void createUserType(HelenusEntity entity) {
sessionOps.execute(SchemaUtil.createUserType(entity), true);
}
public void dropUserType(HelenusEntity entity) {
sessionOps.execute(SchemaUtil.dropUserType(entity), true);
}
public void validateUserType(UserType userType, HelenusEntity entity) {
@ -56,9 +52,11 @@ 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);
}
}
public void updateUserType(UserType userType, HelenusEntity entity) {
@ -69,15 +67,13 @@ public final class UserTypeOperations {
}
executeBatch(SchemaUtil.alterUserType(userType, entity, dropUnusedColumns));
}
private void executeBatch(List<SchemaStatement> list) {
list.forEach(s -> {
list.forEach(
s -> {
sessionOps.execute(s, true);
});
}
}

3
src/main/java/net/helenus/core/annotation/Cacheable.java
View file

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

1
src/main/java/net/helenus/core/annotation/Retry.java
View file

@ -4,7 +4,6 @@ import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import net.helenus.core.ConflictingUnitOfWorkException;
@Retention(RetentionPolicy.RUNTIME)

8
src/main/java/net/helenus/core/aspect/RetryConcurrentUnitOfWorkAspect.java
View file

@ -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) {

5
src/main/java/net/helenus/core/operation/AbstractFilterOperation.java
View file

@ -17,12 +17,10 @@ package net.helenus.core.operation;
import java.util.LinkedList;
import java.util.List;
import net.helenus.core.*;
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;
@ -107,5 +105,4 @@ public abstract class AbstractFilterOperation<E, O extends AbstractFilterOperati
}
ifFilters.add(filter);
}
}

8
src/main/java/net/helenus/core/operation/AbstractFilterOptionalOperation.java
View file

@ -17,12 +17,11 @@ package net.helenus.core.operation;
import java.util.LinkedList;
import java.util.List;
import net.helenus.core.*;
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 List<Filter<?>> filters = null;
protected List<Filter<?>> ifFilters = null;
@ -107,5 +106,4 @@ public abstract class AbstractFilterOptionalOperation<E, O extends AbstractFilte
}
ifFilters.add(filter);
}
}

5
src/main/java/net/helenus/core/operation/AbstractFilterStreamOperation.java
View file

@ -17,10 +17,10 @@ package net.helenus.core.operation;
import java.util.LinkedList;
import java.util.List;
import net.helenus.core.*;
public abstract class AbstractFilterStreamOperation<E, O extends AbstractFilterStreamOperation<E, O>>
public abstract class AbstractFilterStreamOperation<
E, O extends AbstractFilterStreamOperation<E, O>>
extends AbstractStreamOperation<E, O> {
protected List<Filter<?>> filters = null;
@ -106,5 +106,4 @@ public abstract class AbstractFilterStreamOperation<E, O extends AbstractFilterS
}
ifFilters.add(filter);
}
}

15
src/main/java/net/helenus/core/operation/AbstractOperation.java
View file

@ -16,12 +16,11 @@
package net.helenus.core.operation;
import com.datastax.driver.core.ResultSet;
import java.util.concurrent.CompletableFuture;
import net.helenus.core.AbstractSessionOperations;
import java.util.concurrent.CompletableFuture;
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 abstract E transform(ResultSet resultSet);
@ -42,7 +41,8 @@ public abstract class AbstractOperation<E, O extends AbstractOperation<E, O>> ex
}
public E sync() {
ResultSet resultSet = sessionOps.executeAsync(options(buildStatement()), showValues).getUninterruptibly();
ResultSet resultSet =
sessionOps.executeAsync(options(buildStatement()), showValues).getUninterruptibly();
E result = transform(resultSet);
if (cacheable()) {
sessionOps.cache(getCacheKey(), result);
@ -50,6 +50,7 @@ public abstract class AbstractOperation<E, O extends AbstractOperation<E, O>> ex
return result;
}
public CompletableFuture<E> async() { return CompletableFuture.supplyAsync(this::sync); }
public CompletableFuture<E> async() {
return CompletableFuture.supplyAsync(this::sync);
}
}

26
src/main/java/net/helenus/core/operation/AbstractOptionalOperation.java
View file

@ -23,9 +23,8 @@ import com.datastax.driver.core.ResultSetFuture;
import com.google.common.base.Function;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import net.helenus.core.AbstractSessionOperations;
import java.util.Optional;
import net.helenus.core.AbstractSessionOperations;
public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOperation<E, O>>
extends AbstractStatementOperation<E, O> {
@ -42,7 +41,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) {
@ -53,13 +53,15 @@ public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOpe
public Optional<E> sync() {
Tracer tracer = this.sessionOps.getZipkinTracer();
final Span cassandraSpan = (tracer != null && traceContext != null) ? tracer.newChild(traceContext) : null;
final Span cassandraSpan =
(tracer != null && traceContext != null) ? tracer.newChild(traceContext) : null;
if (cassandraSpan != null) {
cassandraSpan.name("cassandra");
cassandraSpan.start();
}
ResultSet resultSet = sessionOps.executeAsync(options(buildStatement()), showValues).getUninterruptibly();
ResultSet resultSet =
sessionOps.executeAsync(options(buildStatement()), showValues).getUninterruptibly();
Optional<E> result = transform(resultSet);
if (cassandraSpan != null) {
@ -71,14 +73,18 @@ public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOpe
public ListenableFuture<Optional<E>> async() {
final Tracer tracer = this.sessionOps.getZipkinTracer();
final Span cassandraSpan = (tracer != null && traceContext != null) ? tracer.newChild(traceContext) : null;
final Span cassandraSpan =
(tracer != null && traceContext != null) ? tracer.newChild(traceContext) : null;
if (cassandraSpan != null) {
cassandraSpan.name("cassandra");
cassandraSpan.start();
}
ResultSetFuture resultSetFuture = sessionOps.executeAsync(options(buildStatement()), showValues);
ListenableFuture<Optional<E>> future = Futures.transform(resultSetFuture,
ResultSetFuture resultSetFuture =
sessionOps.executeAsync(options(buildStatement()), showValues);
ListenableFuture<Optional<E>> future =
Futures.transform(
resultSetFuture,
new Function<ResultSet, Optional<E>>() {
@Override
public Optional<E> apply(ResultSet resultSet) {
@ -88,9 +94,9 @@ public abstract class AbstractOptionalOperation<E, O extends AbstractOptionalOpe
}
return result;
}
}, sessionOps.getExecutor());
},
sessionOps.getExecutor());
return future;
}
}

9
src/main/java/net/helenus/core/operation/AbstractStatementOperation.java
View file

@ -17,9 +17,6 @@ package net.helenus.core.operation;
import brave.Tracer;
import brave.propagation.TraceContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.datastax.driver.core.ConsistencyLevel;
import com.datastax.driver.core.PreparedStatement;
import com.datastax.driver.core.RegularStatement;
@ -30,10 +27,10 @@ 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 net.helenus.core.AbstractSessionOperations;
import net.helenus.support.HelenusException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public abstract class AbstractStatementOperation<E, O extends AbstractStatementOperation<E, O>> {
@ -264,10 +261,8 @@ public abstract class AbstractStatementOperation<E, O extends AbstractStatementO
RegularStatement regularStatement = (RegularStatement) statement;
return sessionOps.prepareAsync(regularStatement);
}
throw new HelenusException("only RegularStatements can be prepared");
}
}

27
src/main/java/net/helenus/core/operation/AbstractStreamOperation.java
View file

@ -15,8 +15,6 @@
*/
package net.helenus.core.operation;
import java.util.stream.Stream;
import brave.Span;
import brave.Tracer;
import com.datastax.driver.core.PreparedStatement;
@ -25,7 +23,7 @@ import com.datastax.driver.core.ResultSetFuture;
import com.google.common.base.Function;
import com.google.common.util.concurrent.Futures;
import com.google.common.util.concurrent.ListenableFuture;
import java.util.stream.Stream;
import net.helenus.core.AbstractSessionOperations;
public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperation<E, O>>
@ -43,7 +41,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) {
@ -54,13 +53,15 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
public Stream<E> sync() {
Tracer tracer = this.sessionOps.getZipkinTracer();
final Span cassandraSpan = (tracer != null && traceContext != null) ? tracer.newChild(traceContext) : null;
final Span cassandraSpan =
(tracer != null && traceContext != null) ? tracer.newChild(traceContext) : null;
if (cassandraSpan != null) {
cassandraSpan.name("cassandra");
cassandraSpan.start();
}
ResultSet resultSet = sessionOps.executeAsync(options(buildStatement()), showValues).getUninterruptibly();
ResultSet resultSet =
sessionOps.executeAsync(options(buildStatement()), showValues).getUninterruptibly();
Stream<E> result = transform(resultSet);
if (cassandraSpan != null) {
@ -72,14 +73,18 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
public ListenableFuture<Stream<E>> async() {
Tracer tracer = this.sessionOps.getZipkinTracer();
final Span cassandraSpan = (tracer != null && traceContext != null) ? tracer.newChild(traceContext) : null;
final Span cassandraSpan =
(tracer != null && traceContext != null) ? tracer.newChild(traceContext) : null;
if (cassandraSpan != null) {
cassandraSpan.name("cassandra");
cassandraSpan.start();
}
ResultSetFuture resultSetFuture = sessionOps.executeAsync(options(buildStatement()), showValues);
ListenableFuture<Stream<E>> future = Futures.transform(resultSetFuture,
ResultSetFuture resultSetFuture =
sessionOps.executeAsync(options(buildStatement()), showValues);
ListenableFuture<Stream<E>> future =
Futures.transform(
resultSetFuture,
new Function<ResultSet, Stream<E>>() {
@Override
public Stream<E> apply(ResultSet resultSet) {
@ -89,8 +94,8 @@ public abstract class AbstractStreamOperation<E, O extends AbstractStreamOperati
}
return result;
}
}, sessionOps.getExecutor());
},
sessionOps.getExecutor());
return future;
}
}

1
src/main/java/net/helenus/core/operation/BoundOperation.java
View file

@ -39,5 +39,4 @@ public final class BoundOperation<E> extends AbstractOperation<E, BoundOperation
public Statement buildStatement() {
return boundStatement;
}
}

10
src/main/java/net/helenus/core/operation/BoundOptionalOperation.java
View file

@ -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;
@ -41,5 +42,4 @@ public final class BoundOptionalOperation<E> extends AbstractOptionalOperation<E
public Statement buildStatement() {
return boundStatement;
}
}

10
src/main/java/net/helenus/core/operation/BoundStreamOperation.java
View file

@ -15,18 +15,19 @@
*/
package net.helenus.core.operation;
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.stream.Stream;
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;
@ -41,5 +42,4 @@ public final class BoundStreamOperation<E> extends AbstractStreamOperation<E, Bo
public Statement buildStatement() {
return boundStatement;
}
}

9
src/main/java/net/helenus/core/operation/CountOperation.java
View file

@ -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,9 +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());
}
}
}

8
src/main/java/net/helenus/core/operation/DeleteOperation.java
View file

@ -20,7 +20,6 @@ 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 net.helenus.core.AbstractSessionOperations;
import net.helenus.core.Filter;
import net.helenus.core.reflect.HelenusPropertyNode;
@ -118,8 +117,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());
}
}
}

36
src/main/java/net/helenus/core/operation/InsertOperation.java
View file

@ -19,12 +19,13 @@ 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.function.Function;
import net.helenus.core.AbstractSessionOperations;
import net.helenus.core.Getter;
import net.helenus.core.Helenus;
import net.helenus.core.reflect.DefaultPrimitiveTypes;
import net.helenus.core.reflect.HelenusPropertyNode;
import net.helenus.core.reflect.MapExportable;
import net.helenus.mapping.HelenusEntity;
import net.helenus.mapping.HelenusProperty;
import net.helenus.mapping.MappingUtil;
@ -33,14 +34,12 @@ import net.helenus.support.Fun;
import net.helenus.support.HelenusException;
import net.helenus.support.HelenusMappingException;
import java.util.*;
import java.util.function.Function;
public final class InsertOperation<T> extends AbstractOperation<T, InsertOperation<T>> {
private HelenusEntity entity;
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 boolean ifNotExists;
private Object pojo;
@ -53,8 +52,12 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
this.ifNotExists = ifNotExists;
}
public InsertOperation(AbstractSessionOperations sessionOperations, HelenusEntity entity,
Object pojo, Set<String> mutations, boolean ifNotExists) {
public InsertOperation(
AbstractSessionOperations sessionOperations,
HelenusEntity entity,
Object pojo,
Set<String> mutations,
boolean ifNotExists) {
super(sessionOperations);
this.entity = entity;
@ -74,11 +77,8 @@ public final class InsertOperation<T> extends AbstractOperation<T, InsertOperati
HelenusPropertyNode node = new HelenusPropertyNode(prop, Optional.empty());
values.add(Fun.Tuple2.of(node, value));
}
}
}
}
public InsertOperation<T> ifNotExists() {
@ -112,8 +112,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");
@ -125,7 +124,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);
});
@ -157,7 +157,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)));
}
@ -203,8 +204,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());
}
}
}

1
src/main/java/net/helenus/core/operation/PreparedOperation.java
View file

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

4
src/main/java/net/helenus/core/operation/PreparedOptionalOperation.java
View file

@ -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;
}
@ -43,5 +44,4 @@ public final class PreparedOptionalOperation<E> {
public String toString() {
return preparedStatement.getQueryString();
}
}

4
src/main/java/net/helenus/core/operation/PreparedStreamOperation.java
View file

@ -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;
}
@ -43,5 +44,4 @@ public final class PreparedStreamOperation<E> {
public String toString() {
return preparedStatement.getQueryString();
}
}

9
src/main/java/net/helenus/core/operation/SelectFirstOperation.java
View file

@ -15,13 +15,13 @@
*/
package net.helenus.core.operation;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.querybuilder.BuiltStatement;
import java.util.Optional;
import java.util.function.Function;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.querybuilder.BuiltStatement;
public final class SelectFirstOperation<E> extends AbstractFilterOptionalOperation<E, SelectFirstOperation<E>> {
public final class SelectFirstOperation<E>
extends AbstractFilterOptionalOperation<E, SelectFirstOperation<E>> {
private final SelectOperation<E> src;
@ -46,5 +46,4 @@ public final class SelectFirstOperation<E> extends AbstractFilterOptionalOperati
public Optional<E> transform(ResultSet resultSet) {
return src.transform(resultSet).findFirst();
}
}

9
src/main/java/net/helenus/core/operation/SelectFirstTransformingOperation.java
View file

@ -15,15 +15,13 @@
*/
package net.helenus.core.operation;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.querybuilder.BuiltStatement;
import java.util.Optional;
import java.util.function.Function;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.querybuilder.BuiltStatement;
public final class SelectFirstTransformingOperation<R, E>
extends
AbstractFilterOptionalOperation<R, SelectFirstTransformingOperation<R, E>> {
extends AbstractFilterOptionalOperation<R, SelectFirstTransformingOperation<R, E>> {
private final SelectOperation<E> src;
private final Function<E, R> fn;
@ -46,5 +44,4 @@ public final class SelectFirstTransformingOperation<R, E>
public Optional<R> transform(ResultSet resultSet) {
return src.transform(resultSet).findFirst().map(fn);
}
}

73
src/main/java/net/helenus/core/operation/SelectOperation.java
View file

@ -15,11 +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 com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Row;
import com.datastax.driver.core.querybuilder.BuiltStatement;
@ -28,7 +23,10 @@ import com.datastax.driver.core.querybuilder.QueryBuilder;
import com.datastax.driver.core.querybuilder.Select;
import com.datastax.driver.core.querybuilder.Select.Selection;
import com.datastax.driver.core.querybuilder.Select.Where;
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.reflect.HelenusPropertyNode;
import net.helenus.mapping.HelenusEntity;
@ -51,7 +49,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) {
@ -67,7 +66,6 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
return (E) Fun.ArrayTuple.of(arr);
}
};
}
@ -75,23 +73,31 @@ 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));
}
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));
}
public SelectOperation(AbstractSessionOperations sessionOperations, Function<Row, E> rowMapper,
public SelectOperation(
AbstractSessionOperations sessionOperations,
Function<Row, E> rowMapper,
HelenusPropertyNode... props) {
super(sessionOperations);
@ -107,8 +113,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());
}
}
@ -128,11 +137,11 @@ 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);
});
}
@ -182,8 +191,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 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());
}
}
@ -211,7 +223,8 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
}
if (ifFilters != null && !ifFilters.isEmpty()) {
logger.error("onlyIf conditions " + ifFilters + " would be ignored in the statement " + select);
logger.error(
"onlyIf conditions " + ifFilters + " would be ignored in the statement " + select);
}
if (allowFiltering) {
@ -227,16 +240,15 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
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);
} else {
return (Stream<E>)
StreamSupport.stream(
Spliterators.spliteratorUnknownSize(resultSet.iterator(), Spliterator.ORDERED),
false);
}
}
@ -246,5 +258,4 @@ public final class SelectOperation<E> extends AbstractFilterStreamOperation<E, S
}
return ordering;
}
}

9
src/main/java/net/helenus/core/operation/SelectTransformingOperation.java
View file

@ -15,15 +15,13 @@
*/
package net.helenus.core.operation;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.querybuilder.BuiltStatement;
import java.util.function.Function;
import java.util.stream.Stream;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.querybuilder.BuiltStatement;
public final class SelectTransformingOperation<R, E>
extends
AbstractFilterStreamOperation<R, SelectTransformingOperation<R, E>> {
extends AbstractFilterStreamOperation<R, SelectTransformingOperation<R, E>> {
private final SelectOperation<E> src;
private final Function<E, R> fn;
@ -46,5 +44,4 @@ public final class SelectTransformingOperation<R, E>
public Stream<R> transform(ResultSet resultSet) {
return src.transform(resultSet).map(fn);
}
}

40
src/main/java/net/helenus/core/operation/UpdateOperation.java
View file

@ -15,15 +15,13 @@
*/
package net.helenus.core.operation;
import java.util.*;
import java.util.function.Function;
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.function.Function;
import net.helenus.core.AbstractSessionOperations;
import net.helenus.core.Filter;
import net.helenus.core.Getter;
@ -47,7 +45,8 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
super(sessionOperations);
}
public UpdateOperation(AbstractSessionOperations sessionOperations, HelenusPropertyNode p, Object v) {
public UpdateOperation(
AbstractSessionOperations sessionOperations, HelenusPropertyNode p, Object v) {
super(sessionOperations);
Object value = sessionOps.getValuePreparer().prepareColumnValue(v, p.getProperty());
@ -91,7 +90,6 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
addPropertyNode(p);
return this;
}
public <V> UpdateOperation decrement(Getter<V> counterGetter) {
@ -108,7 +106,6 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
addPropertyNode(p);
return this;
}
/*
@ -221,7 +218,8 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
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);
@ -236,7 +234,8 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
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);
}
@ -313,7 +312,8 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
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();
@ -327,7 +327,8 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
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);
}
@ -351,10 +352,11 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
HelenusPropertyNode p = MappingUtil.resolveMappingProperty(mapGetter);
HelenusProperty prop = p.getProperty();
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.add(QueryBuilder.put(p.getColumnName(), e.getKey(), e.getValue()));
}
@ -374,7 +376,8 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
HelenusPropertyNode p = MappingUtil.resolveMappingProperty(mapGetter);
HelenusProperty prop = p.getProperty();
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.add(QueryBuilder.putAll(p.getColumnName(), convertedMap));
@ -444,8 +447,11 @@ public final class UpdateOperation extends AbstractFilterOperation<ResultSet, Up
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());
}
}
}

15
src/main/java/net/helenus/core/reflect/DefaultPrimitiveTypes.java
View file

@ -19,14 +19,20 @@ 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 final Class<?> primitiveClass;
private final Object defaultValue;
private final static 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()) {
@ -50,5 +56,4 @@ public enum DefaultPrimitiveTypes {
public Object getDefaultValue() {
return defaultValue;
}
}

1
src/main/java/net/helenus/core/reflect/Drafted.java
View file

@ -7,5 +7,4 @@ public interface Drafted<T> extends MapExportable {
Set<String> mutated();
T build();
}

1
src/main/java/net/helenus/core/reflect/DslExportable.java
View file

@ -25,5 +25,4 @@ public interface DslExportable {
HelenusEntity getHelenusMappingEntity();
HelenusPropertyNode getParentDslHelenusPropertyNode();
}

41
src/main/java/net/helenus/core/reflect/DslInvocationHandler.java
View file

@ -15,18 +15,13 @@
*/
package net.helenus.core.reflect;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import com.datastax.driver.core.*;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import com.datastax.driver.core.*;
import net.helenus.core.Helenus;
import net.helenus.mapping.HelenusEntity;
import net.helenus.mapping.HelenusMappingEntity;
@ -47,7 +42,11 @@ public class DslInvocationHandler<E> implements InvocationHandler {
private final Map<Method, Object> udtMap = new HashMap<Method, Object>();
private final Map<Method, Object> tupleMap = new HashMap<Method, Object>();
public DslInvocationHandler(Class<E> iface, ClassLoader classLoader, Optional<HelenusPropertyNode> parent, Metadata metadata) {
public DslInvocationHandler(
Class<E> iface,
ClassLoader classLoader,
Optional<HelenusPropertyNode> parent,
Metadata metadata) {
this.entity = new HelenusMappingEntity(iface, metadata);
this.parent = parent;
@ -62,8 +61,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);
}
@ -71,16 +74,19 @@ 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);
}
}
}
}
}
@ -121,7 +127,6 @@ public class DslInvocationHandler<E> implements InvocationHandler {
return parent.get();
}
HelenusProperty prop = map.get(method);
if (prop == null) {
prop = entity.getProperty(methodName);
@ -138,7 +143,6 @@ public class DslInvocationHandler<E> implements InvocationHandler {
if (childDsl != null) {
return childDsl;
}
}
if (type instanceof DTDataType) {
@ -146,9 +150,7 @@ public class DslInvocationHandler<E> implements InvocationHandler {
DataType dt = dataType.getDataType();
switch (dt.getName()) {
case TUPLE:
Object childDsl = tupleMap.get(method);
if (childDsl != null) {
@ -168,9 +170,7 @@ public class DslInvocationHandler<E> implements InvocationHandler {
default:
break;
}
}
throw new DslPropertyException(new HelenusPropertyNode(prop, parent));
@ -178,5 +178,4 @@ public class DslInvocationHandler<E> implements InvocationHandler {
throw new HelenusException("invalid method call " + method);
}
}

6
src/main/java/net/helenus/core/reflect/HelenusNamedProperty.java
View file

@ -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;
@ -61,7 +59,9 @@ public final class HelenusNamedProperty implements HelenusProperty {
}
@Override
public boolean caseSensitiveIndex() { return false; }
public boolean caseSensitiveIndex() {
return false;
}
@Override
public Class<?> getJavaType() {

3
src/main/java/net/helenus/core/reflect/HelenusPropertyNode.java
View file

@ -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;
@ -102,7 +101,5 @@ public final class HelenusPropertyNode implements Iterable<HelenusProperty> {
next = node.next;
return node.prop;
}
}
}

1
src/main/java/net/helenus/core/reflect/ListDsl.java
View file

@ -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;

2
src/main/java/net/helenus/core/reflect/MapDsl.java
View file

@ -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;
@ -114,5 +113,4 @@ public final class MapDsl<K, V> implements Map<K, V> {
public String toString() {
return "MapDsl";
}
}

1
src/main/java/net/helenus/core/reflect/MapExportable.java
View file

@ -22,5 +22,4 @@ public interface MapExportable {
public static final String TO_MAP_METHOD = "toMap";
Map<String, Object> toMap();
}

12
src/main/java/net/helenus/core/reflect/MapperInvocationHandler.java
View file

@ -16,7 +16,6 @@
package net.helenus.core.reflect;
import java.io.Serializable;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
@ -24,7 +23,6 @@ import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Collections;
import java.util.Map;
import net.helenus.mapping.annotation.Transient;
import net.helenus.support.HelenusException;
@ -45,13 +43,15 @@ 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)
Object result =
constructor
.newInstance(declaringClass, MethodHandles.Lookup.PRIVATE)
.unreflectSpecial(method, declaringClass)
.bindTo(proxy)
.invokeWithArguments(args);
@ -116,10 +116,8 @@ public class MapperInvocationHandler<E> implements InvocationHandler, Serializab
}
return type.getDefaultValue();
}
}
return value;
}
}

17
src/main/java/net/helenus/core/reflect/ReflectionDslInstantiator.java
View file

@ -15,22 +15,25 @@
*/
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 {
INSTANCE;
@Override
@SuppressWarnings("unchecked")
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);
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);
return proxy;
}
}

5
src/main/java/net/helenus/core/reflect/ReflectionInstantiator.java
View file

@ -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) {
@ -29,7 +28,5 @@ public final class ReflectionInstantiator {
} catch (InstantiationException | IllegalAccessException e) {
throw new HelenusMappingException("invalid class " + clazz, e);
}
}
}

7
src/main/java/net/helenus/core/reflect/ReflectionMapperInstantiator.java
View file

@ -17,11 +17,9 @@ package net.helenus.core.reflect;
import java.lang.reflect.Proxy;
import java.util.Map;
import net.helenus.core.MapperInstantiator;
public enum ReflectionMapperInstantiator implements MapperInstantiator {
INSTANCE;
@Override
@ -29,9 +27,8 @@ 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}, handler);
E proxy =
(E) Proxy.newProxyInstance(classLoader, new Class[] {iface, MapExportable.class}, handler);
return proxy;
}
}

1
src/main/java/net/helenus/core/reflect/SetDsl.java
View file

@ -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> {

17
src/main/java/net/helenus/mapping/ColumnInformation.java
View file

@ -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,15 +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
+ "]";
}
}

5
src/main/java/net/helenus/mapping/ColumnType.java
View file

@ -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;
}

1
src/main/java/net/helenus/mapping/HelenusEntity.java
View file

@ -30,5 +30,4 @@ public interface HelenusEntity {
Collection<HelenusProperty> getOrderedProperties();
HelenusProperty getProperty(String name);
}

4
src/main/java/net/helenus/mapping/HelenusEntityType.java
View file

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

70
src/main/java/net/helenus/mapping/HelenusMappingEntity.java
View file

@ -15,15 +15,11 @@
*/
package net.helenus.mapping;
import java.lang.reflect.Method;
import java.util.*;
import com.datastax.driver.core.*;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.reflect.TypeToken;
import java.lang.reflect.Method;
import java.util.*;
import net.helenus.config.HelenusSettings;
import net.helenus.core.Helenus;
import net.helenus.core.annotation.Cacheable;
@ -56,7 +52,6 @@ public final class HelenusMappingEntity implements HelenusEntity {
HelenusSettings settings = Helenus.settings();
List<Method> methods = new ArrayList<Method>();
methods.addAll(Arrays.asList(iface.getDeclaredMethods()));
@ -80,9 +75,7 @@ public final class HelenusMappingEntity implements HelenusEntity {
propsBuilder.put(prop.getPropertyName(), prop);
propsLocal.add(prop);
}
}
}
this.methods = methodsBuilder.build();
@ -134,7 +127,6 @@ public final class HelenusMappingEntity implements HelenusEntity {
private static IdentityName resolveName(Class<?> iface, HelenusEntityType type) {
switch (type) {
case TABLE:
return MappingUtil.getTableName(iface, true);
@ -146,7 +138,6 @@ public final class HelenusMappingEntity implements HelenusEntity {
}
throw new HelenusMappingException("invalid entity type " + type + " in " + type);
}
private static HelenusEntityType autoDetectType(Class<?> iface) {
@ -155,23 +146,19 @@ public final class HelenusMappingEntity implements HelenusEntity {
if (null != iface.getDeclaredAnnotation(Table.class)) {
return HelenusEntityType.TABLE;
}
else if (null != iface.getDeclaredAnnotation(Tuple.class)) {
} else if (null != iface.getDeclaredAnnotation(Tuple.class)) {
return HelenusEntityType.TUPLE;
}
else if (null != iface.getDeclaredAnnotation(UDT.class)) {
} else if (null != iface.getDeclaredAnnotation(UDT.class)) {
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);
}
private void validateOrdinals() {
switch (getType()) {
case TABLE:
validateOrdinalsForTable();
break;
@ -183,7 +170,6 @@ public final class HelenusMappingEntity implements HelenusEntity {
default:
break;
}
}
private void validateOrdinalsForTable() {
@ -198,11 +184,12 @@ public final class HelenusMappingEntity implements HelenusEntity {
int ordinal = prop.getOrdinal();
switch (type) {
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);
@ -210,8 +197,11 @@ public final class HelenusMappingEntity implements HelenusEntity {
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;
@ -219,30 +209,36 @@ public final class HelenusMappingEntity implements HelenusEntity {
default:
break;
}
}
}
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;
});
for (int i = 0; i != ordinals.length; ++i) {
@ -250,15 +246,18 @@ public final class HelenusMappingEntity implements HelenusEntity {
throw new HelenusMappingException("detected absent ordinal " + i + " in " + this);
}
}
}
@Override
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());
@ -266,5 +265,4 @@ public final class HelenusMappingEntity implements HelenusEntity {
}
return str.toString();
}
}

12
src/main/java/net/helenus/mapping/HelenusMappingProperty.java
View file

@ -15,15 +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;
@ -64,8 +62,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);
}
@ -169,7 +168,6 @@ public final class HelenusMappingProperty implements HelenusProperty {
ColumnType type = this.getColumnType();
switch (type) {
case PARTITION_KEY:
str.append("partition_key[");
str.append(this.getOrdinal());
@ -192,7 +190,6 @@ public final class HelenusMappingProperty implements HelenusProperty {
case COLUMN:
break;
}
Optional<IdentityName> idx = this.getIndexName();
@ -202,5 +199,4 @@ public final class HelenusMappingProperty implements HelenusProperty {
return str.toString();
}
}

3
src/main/java/net/helenus/mapping/HelenusProperty.java
View file

@ -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;
@ -54,5 +52,4 @@ public interface HelenusProperty {
Optional<Function<Object, Object>> getWriteConverter(SessionRepository repository);
ConstraintValidator<? extends Annotation, ?>[] getValidators();
}

1
src/main/java/net/helenus/mapping/IdentityName.java
View file

@ -56,5 +56,4 @@ public final class IdentityName {
public String toString() {
return toCql();
}
}

52
src/main/java/net/helenus/mapping/MappingUtil.java
View file

@ -20,10 +20,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.*;
@ -37,10 +35,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) {
@ -55,9 +53,7 @@ public final class MappingUtil {
for (Annotation possibleConstraint : annotationType.getDeclaredAnnotations()) {
list = addValidators(possibleConstraint, list);
}
}
if (list == null) {
@ -67,8 +63,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();
@ -80,8 +76,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);
@ -90,15 +86,11 @@ public final class MappingUtil {
}
list.add(validator);
}
}
}
return list;
}
public static Optional<IdentityName> getIndexName(Method getterMethod) {
@ -115,10 +107,11 @@ public final class MappingUtil {
if (indexName == null || indexName.isEmpty()) {
indexName = getDefaultColumnName(getterMethod);
}
}
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) {
@ -156,7 +149,6 @@ public final class MappingUtil {
}
return new IdentityName(userTypeName, forceQuote);
}
if (required) {
@ -164,7 +156,6 @@ public final class MappingUtil {
}
return null;
}
public static boolean isTuple(Class<?> iface) {
@ -172,7 +163,6 @@ public final class MappingUtil {
Tuple tuple = iface.getDeclaredAnnotation(Tuple.class);
return tuple != null;
}
public static boolean isUDT(Class<?> iface) {
@ -180,7 +170,6 @@ public final class MappingUtil {
UDT udt = iface.getDeclaredAnnotation(UDT.class);
return udt != null;
}
public static IdentityName getTableName(Class<?> iface, boolean required) {
@ -232,15 +221,13 @@ public final class MappingUtil {
continue;
}
if (iface.getDeclaredAnnotation(Table.class) != null || iface.getDeclaredAnnotation(UDT.class) != null
if (iface.getDeclaredAnnotation(Table.class) != null
|| iface.getDeclaredAnnotation(UDT.class) != null
|| iface.getDeclaredAnnotation(Tuple.class) != null) {
break;
}
}
}
if (iface == null) {
@ -248,7 +235,6 @@ public final class MappingUtil {
}
return iface;
}
public static HelenusPropertyNode resolveMappingProperty(Getter<?> getter) {
@ -259,19 +245,13 @@ public final class MappingUtil {
if (childDsl instanceof DslExportable) {
DslExportable e = (DslExportable) childDsl;
return e.getParentDslHelenusPropertyNode();
}
else if (childDsl instanceof MapDsl) {
} else if (childDsl instanceof MapDsl) {
MapDsl mapDsl = (MapDsl) childDsl;
return mapDsl.getParent();
}
else if (childDsl instanceof ListDsl) {
} else if (childDsl instanceof ListDsl) {
ListDsl listDsl = (ListDsl) childDsl;
return listDsl.getParent();
}
else if (childDsl instanceof SetDsl) {
} else if (childDsl instanceof SetDsl) {
SetDsl setDsl = (SetDsl) childDsl;
return setDsl.getParent();
}
@ -281,7 +261,5 @@ public final class MappingUtil {
} catch (DslPropertyException e) {
return e.getPropertyNode();
}
}
}

6
src/main/java/net/helenus/mapping/OrderingDirection.java
View file

@ -18,7 +18,6 @@ package net.helenus.mapping;
import net.helenus.support.HelenusMappingException;
public enum OrderingDirection {
ASC("ASC"),
DESC("DESC");
@ -37,13 +36,10 @@ public enum OrderingDirection {
if (ASC.cql.equalsIgnoreCase(name)) {
return ASC;
}
else if (DESC.cql.equalsIgnoreCase(name)) {
} else if (DESC.cql.equalsIgnoreCase(name)) {
return DESC;
}
throw new HelenusMappingException("invalid ordering direction name " + name);
}
}

5
src/main/java/net/helenus/mapping/TypeAndOrdinalColumnComparator.java
View file

@ -18,12 +18,12 @@ package net.helenus.mapping;
import java.util.Comparator;
public enum TypeAndOrdinalColumnComparator implements Comparator<HelenusProperty> {
INSTANCE;
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());
@ -31,5 +31,4 @@ public enum TypeAndOrdinalColumnComparator implements Comparator<HelenusProperty
return c;
}
}

79
src/main/java/net/helenus/mapping/annotation/ClusteringColumn.java
View file

@ -19,43 +19,35 @@ 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
*
* 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.
*
* 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.
*
* 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.
*
* 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=?
*
* 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>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>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})
public @interface ClusteringColumn {
@ -65,47 +57,40 @@ public @interface ClusteringColumn {
*
* @return name of the column
*/
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.
*
* 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.
*
* 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.
*
* 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;
}

32
src/main/java/net/helenus/mapping/annotation/Column.java
View file

@ -18,20 +18,16 @@ 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 can be used to override default name of the column or to
* setup order of the columns in the mapping
*
* 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
* 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>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)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -42,29 +38,25 @@ public @interface Column {
*
* @return name of the column
*/
String value() default "";
/**
* Ordinal will be used for ascending sorting of columns
*
* 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.
*
* 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;
}

151
src/main/java/net/helenus/mapping/annotation/Constraints.java
View file

@ -16,111 +16,84 @@
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.
*
* All of them does not have effect on selects and data retrieval operations.
*
* Support types: - @NotNull supports any @java.lang.Object type - All
* annotations support @java.lang.String type
* 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>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
*
* Applicable to use in any @java.lang.Object
*
* It does not check on selects and data retrieval operations
* <p>Applicable to use in any @java.lang.Object
*
* <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
*
* 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
*
* Can be used for @java.lang.CharSequence, @ByteBuffer and any array
*
* It does not check on selects and data retrieval operations
* <p>Can be used for @java.lang.CharSequence, @ByteBuffer and any array
*
* <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
*
* Can be used only for @CharSequence
*
* It does not check on selects and data retrieval operations
* <p>Can be used only for @CharSequence
*
* <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
*
* Can be used only for @java.lang.CharSequence
*
* It does not check on selects and data retrieval operations
* <p>Can be used only for @java.lang.CharSequence
*
* <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
*
* Can be used only for @java.lang.CharSequence
*
* It does not check on selects and data retrieval operations
* <p>Can be used only for @java.lang.CharSequence
*
* <p>It does not check on selects and data retrieval operations
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -132,21 +105,16 @@ public final class Constraints {
*
* @return alphabet characters in the string
*/
String value();
}
/**
* 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
*
* Can be used for @java.lang.CharSequence, @ByteBuffer and any array
*
* It does not have effect on selects and data retrieval operations
* <p>Can be used for @java.lang.CharSequence, @ByteBuffer and any array
*
* <p>It does not have effect on selects and data retrieval operations
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -154,19 +122,16 @@ public final class Constraints {
public @interface Length {
int value();
}
/**
* 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
*
* Can be used for @java.lang.CharSequence, @ByteBuffer and byte[]
*
* It does not have effect on selects and data retrieval operations
* <p>Can be used for @java.lang.CharSequence, @ByteBuffer and byte[]
*
* <p>It does not have effect on selects and data retrieval operations
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -174,19 +139,16 @@ public final class Constraints {
public @interface MaxLength {
int value();
}
/**
* 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
*
* Can be used for @java.lang.CharSequence, @ByteBuffer and byte[]
*
* It does not have effect on selects and data retrieval operations
* <p>Can be used for @java.lang.CharSequence, @ByteBuffer and byte[]
*
* <p>It does not have effect on selects and data retrieval operations
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -194,55 +156,42 @@ public final class Constraints {
public @interface MinLength {
int value();
}
/**
* 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
*
* Can be used only for @java.lang.CharSequence
*
* It does not have effect on selects and data retrieval operations
* <p>Can be used only for @java.lang.CharSequence
*
* <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
*
* Can be used only for @java.lang.CharSequence
*
* It does not have effect on selects and data retrieval operations
* <p>Can be used only for @java.lang.CharSequence
*
* <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
*
* Can be used only for @java.lang.CharSequence
*
* It does not have effect on selects and data retrieval operations
* <p>Can be used only for @java.lang.CharSequence
*
* <p>It does not have effect on selects and data retrieval operations
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -254,7 +203,6 @@ public final class Constraints {
*
* @return Java regex pattern
*/
String value();
/**
@ -262,9 +210,6 @@ public final class Constraints {
*
* @return Java regex flags
*/
int flags();
}
}

31
src/main/java/net/helenus/mapping/annotation/Index.java
View file

@ -18,23 +18,19 @@ 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.
*
* The corresponding secondary index will be created in the underline @Table for
* the specific column.
*
* Currently Cassandra supports only single column index, so this index works
* only for single column.
*
* 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>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>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)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -45,18 +41,16 @@ public @interface Index {
*
* @return name of the 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.
*
* 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;
/**
@ -64,6 +58,5 @@ public @interface Index {
*
* @return true if the index should ignore case when comparing
*/
boolean caseSensitive() default true;
}

4
src/main/java/net/helenus/mapping/annotation/InheritedTable.java
View file

@ -20,10 +20,8 @@ import java.lang.annotation.*;
/**
* Inherited Entity annotation
*
* 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)
@Target({ElementType.TYPE})

44
src/main/java/net/helenus/mapping/annotation/PartitionKey.java
View file

@ -21,22 +21,17 @@ 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.
*
* 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.
*
* 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.
* 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>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})
public @interface PartitionKey {
@ -46,33 +41,28 @@ public @interface PartitionKey {
*
* @return name of the column
*/
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.
*
* 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.
*
* 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;
}

23
src/main/java/net/helenus/mapping/annotation/StaticColumn.java
View file

@ -23,16 +23,13 @@ import java.lang.annotation.Target;
/**
* StaticColumn annotation is using to define a static column in Cassandra Table
*
* It does not have effect in @UDT and @Tuple types and in @Table-s that does
* not have @ClusteringColumn-s
*
* 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>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
*/
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
public @interface StaticColumn {
@ -42,7 +39,6 @@ public @interface StaticColumn {
*
* @return name of the column
*/
String value() default "";
/**
@ -50,18 +46,15 @@ public @interface StaticColumn {
*
* @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.
*
* 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;
}

20
src/main/java/net/helenus/mapping/annotation/Table.java
View file

@ -20,16 +20,13 @@ import java.lang.annotation.*;
/**
* Entity annotation
*
* Table annotation is used to define Table mapping to some interface
*
* There are three types of Entity mapping annotations: @Table, @UDT, @Tuple
*
* For each @Table annotated interface Helenus will create/update/verify
* Cassandra Table and some indexes if needed on startup.
* <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>For each @Table annotated interface Helenus will create/update/verify Cassandra Table and some
* indexes if needed on startup.
*/
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
@ -40,18 +37,15 @@ public @interface Table {
*
* @return name of the UDT type
*/
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.
*
* 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;
}

9
src/main/java/net/helenus/mapping/annotation/Transient.java
View file

@ -17,13 +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 {}

17
src/main/java/net/helenus/mapping/annotation/Tuple.java
View file

@ -20,20 +20,15 @@ import java.lang.annotation.*;
/**
* Entity annotation
*
* Tuple annotation is used to define Tuple type mapping to some interface
*
* There are three types of Entity mapping annotations: @Table, @UDT, @Tuple
*
* 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 annotation is used to define Tuple type mapping to some interface
*
* <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
*/
@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface Tuple {
}
public @interface Tuple {}

388
src/main/java/net/helenus/mapping/annotation/Types.java
View file

@ -15,211 +15,163 @@
*/
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.
*
* 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
*
* 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.
*
* For complex types like collections, UDF and Tuple types all those annotations
* are using to clarify the sub-type(s) or class/UDF names.
*
* Has significant effect on schema operations.
* <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>Has significant effect on schema operations.
*/
public final class Types {
private Types() {
}
/**
* Says to use @DataType.Name.ASCII data type in schema Java type is @String
*/
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 {
}
/**
* Says to use @DataType.Name.BIGINT data type in schema Java type is @Long
*/
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
*
* 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.
*
* 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.
*
* 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)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
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)
*
* 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
*/
DataType.Name value();
}
/**
* 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
*
* 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.
*
* 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.
*
* For this type there are special operations: put and putAll
* in @UpdateOperation.
* <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.
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
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)
*
* 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)
*
* 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
*/
DataType.Name value();
}
/**
* Says to use @DataType.Name.COUNTER type in schema Java type is @Long
*
* 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
*
* 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.
*
* 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.
*
* 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
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
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)
*
* 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
*/
DataType.Name value();
}
/**
* 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[]
*
* 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)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -230,131 +182,95 @@ public final class Types {
*
* @return class name of the custom type implementation
*/
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 {
}
/**
* Says to use @DataType.Name.TIMESTAMP type in schema Java type is @Date Using
* by default
*/
public @interface Text {}
/** 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 {
}
/**
* Says to use @DataType.Name.TIMEUUID type in schema Java type is @UUID
* or @Date
*/
public @interface Timestamp {}
/** 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
*
* 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
*/
DataType.Name[] value() default {};
}
/**
* 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)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
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.
*
* 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
*
* 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
*/
String value() default "";
/**
* Only used for JavaType @UDTValue
*
* 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.
*
* Default value is false.
* <p>Default value is false.
*
* @return true if quotation is needed
*/
boolean forceQuote() default false;
}
/**
* 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
*
* 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.
*
* 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.
*
* For this type there are special operations: put and putAll
* in @UpdateOperation.
* <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.
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -365,39 +281,32 @@ public final class Types {
*
* @return annotation of UDT type
*/
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)
*
* 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
*/
DataType.Name value();
}
/**
* 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
*
* 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.
*
* 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.
*
* 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)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -408,28 +317,21 @@ public final class Types {
*
* @return annotation of the UDT value
*/
UDT value();
}
/**
* 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
*
* 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.
*
* 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.
*
* For this type there are special operations: put and putAll
* in @UpdateOperation.
* <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.
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -440,37 +342,28 @@ public final class Types {
*
* @return annotation of the UDT key
*/
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
*/
UDT value();
}
/**
* 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
*
* 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.
*
* 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.
*
* 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
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
@ -481,76 +374,53 @@ public final class Types {
*
* @return annotation of the UDT value
*/
UDT value();
}
/**
* 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
*
* 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.
*
* 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.
*
* For this type there are special operations: put and putAll
* in @UpdateOperation.
* <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.
*/
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.METHOD, ElementType.ANNOTATION_TYPE})
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)
*
* 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 {
}
/**
* Says to use @DataType.Name.VARCHAR type in schema Java type is @String
*/
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 {}
}

17
src/main/java/net/helenus/mapping/annotation/UDT.java
View file

@ -18,14 +18,12 @@ package net.helenus.mapping.annotation;
/**
* Entity annotation
*
* UDT annotation is used to define the UDT (User Defined Type) mapping for some interface
* <p>UDT annotation is used to define the UDT (User Defined Type) mapping for some interface
*
* There are three types of Entity mapping annotations: @Table, @UDT, @Tuple
*
* For each annotated @UDT type Helenus will create/update/verify Cassandra Type on startup
* <p>There are three types of Entity mapping annotations: @Table, @UDT, @Tuple
*
* <p>For each annotated @UDT type Helenus will create/update/verify Cassandra Type on startup
*/
import java.lang.annotation.*;
@Inherited
@ -38,18 +36,15 @@ public @interface UDT {
*
* @return name of the UDT type
*/
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.
*
* 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;
}

7
src/main/java/net/helenus/mapping/convert/AbstractEntityValueWriter.java
View file

@ -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;
@ -54,9 +53,7 @@ public abstract class AbstractEntityValueWriter<V> {
if (prop != null) {
writeColumn(outValue, value, prop);
}
}
} else {
@ -68,11 +65,7 @@ public abstract class AbstractEntityValueWriter<V> {
if (value != null) {
writeColumn(outValue, value, prop);
}
}
}
}
}

2
src/main/java/net/helenus/mapping/convert/ByteArrayToByteBufferConverter.java
View file

@ -19,7 +19,6 @@ import java.nio.ByteBuffer;
import java.util.function.Function;
public enum ByteArrayToByteBufferConverter implements Function<byte[], ByteBuffer> {
INSTANCE;
@Override
@ -31,5 +30,4 @@ public enum ByteArrayToByteBufferConverter implements Function<byte[], ByteBuffe
return ByteBuffer.wrap(t);
}
}

2
src/main/java/net/helenus/mapping/convert/ByteBufferToByteArrayConverter.java
View file

@ -19,7 +19,6 @@ import java.nio.ByteBuffer;
import java.util.function.Function;
public enum ByteBufferToByteArrayConverter implements Function<ByteBuffer, byte[]> {
INSTANCE;
@Override
@ -31,5 +30,4 @@ public enum ByteBufferToByteArrayConverter implements Function<ByteBuffer, byte[
return t.array();
}
}

5
src/main/java/net/helenus/mapping/convert/CamelCaseToUnderscoreConverter.java
View file

@ -15,12 +15,10 @@
*/
package net.helenus.mapping.convert;
import com.google.common.base.CaseFormat;
import java.util.function.Function;
import com.google.common.base.CaseFormat;
public enum CamelCaseToUnderscoreConverter implements Function<String, String> {
INSTANCE;
@Override
@ -32,5 +30,4 @@ public enum CamelCaseToUnderscoreConverter implements Function<String, String> {
return CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, source);
}
}

9
src/main/java/net/helenus/mapping/convert/DateToTimeuuidConverter.java
View file

@ -18,16 +18,10 @@ 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
*
*/
/** Simple Date to TimeUUID Converter */
public enum DateToTimeuuidConverter implements Function<Date, UUID> {
INSTANCE;
@Override
@ -35,5 +29,4 @@ public enum DateToTimeuuidConverter implements Function<Date, UUID> {
long milliseconds = source.getTime();
return Timeuuid.of(milliseconds);
}
}

8
src/main/java/net/helenus/mapping/convert/EnumToStringConverter.java
View file

@ -17,18 +17,12 @@ package net.helenus.mapping.convert;
import java.util.function.Function;
/**
* Enum to String Converter
*
*/
/** Enum to String Converter */
public enum EnumToStringConverter implements Function<Enum, String> {
INSTANCE;
@Override
public String apply(Enum source) {
return source.name();
}
}

2
src/main/java/net/helenus/mapping/convert/ProxyValueReader.java
View file

@ -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;
@ -44,5 +43,4 @@ public class ProxyValueReader<T> implements Function<T, Object> {
}
return null;
}
}

1
src/main/java/net/helenus/mapping/convert/StringToEnumConverter.java
View file

@ -29,5 +29,4 @@ public class StringToEnumConverter implements Function<String, Enum> {
public Enum apply(String source) {
return Enum.valueOf(enumClass, source);
}
}

3
src/main/java/net/helenus/mapping/convert/TimeuuidToDateConverter.java
View file

@ -18,16 +18,13 @@ package net.helenus.mapping.convert;
import java.util.Date;
import java.util.UUID;
import java.util.function.Function;
import net.helenus.support.Timeuuid;
public enum TimeuuidToDateConverter implements Function<UUID, Date> {
INSTANCE;
@Override
public Date apply(UUID source) {
return new Date(Timeuuid.getTimestampMillis(source));
}
}

10
src/main/java/net/helenus/mapping/convert/TupleValueWriter.java
View file

@ -15,17 +15,16 @@
*/
package net.helenus.mapping.convert;
import java.nio.ByteBuffer;
import java.util.function.Function;
import com.datastax.driver.core.TupleType;
import com.datastax.driver.core.TupleValue;
import java.nio.ByteBuffer;
import java.util.function.Function;
import net.helenus.core.SessionRepository;
import net.helenus.mapping.HelenusProperty;
import net.helenus.mapping.value.TupleColumnValuePreparer;
public class TupleValueWriter extends AbstractEntityValueWriter<TupleValue> implements Function<Object, TupleValue> {
public class TupleValueWriter extends AbstractEntityValueWriter<TupleValue>
implements Function<Object, TupleValue> {
private final TupleType tupleType;
private final TupleColumnValuePreparer valuePreparer;
@ -56,5 +55,4 @@ public class TupleValueWriter extends AbstractEntityValueWriter<TupleValue> impl
}
return null;
}
}

Some files were not shown because too many files have changed in this diff Show more