driver-mapping/src/main/java/com/datastax/driver/mapping/AnnotationParser.java - cassandra-java-driver - Git at Google

 /*
  *      Copyright (C) 2012-2015 DataStax Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
  *   You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *   Unless required by applicable law or agreed to in writing, software
  *   distributed under the License is distributed on an "AS IS" BASIS,
  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
 package com.datastax.driver.mapping;

 import com.datastax.driver.core.*;
 import com.datastax.driver.mapping.MethodMapper.ParamMapper;
 import com.datastax.driver.mapping.annotations.*;
 import com.google.common.base.Strings;
 import com.google.common.reflect.TypeToken;

 import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicInteger;

 /**
  * Static methods that facilitates parsing:
  * - {@link #parseEntity(Class, MappingManager)}: entity classes into {@link EntityMapper} instances
  * - {@link #parseUDT(Class, MappingManager)}: UDT classes into {@link MappedUDTCodec} instances.
  * - {@link #parseAccessor(Class, MappingManager)}: Accessor interfaces into {@link AccessorMapper} instances.
  */
 class AnnotationParser {

     private static final Comparator<AliasedMappedProperty<?>> POSITION_COMPARATOR = new Comparator<AliasedMappedProperty<?>>() {
         @Override
         public int compare(AliasedMappedProperty<?> o1, AliasedMappedProperty<?> o2) {
             return o1.mappedProperty.getPosition() - o2.mappedProperty.getPosition();
         }
     };

     private AnnotationParser() {
     }

     static <T> EntityMapper<T> parseEntity(final Class<T> entityClass, MappingManager mappingManager) {
         Table table = AnnotationChecks.getTypeAnnotation(Table.class, entityClass);

         String ksName = table.caseSensitiveKeyspace() ? Metadata.quote(table.keyspace()) : table.keyspace().toLowerCase();
         String tableName = table.caseSensitiveTable() ? Metadata.quote(table.name()) : table.name().toLowerCase();

         ConsistencyLevel writeConsistency = table.writeConsistency().isEmpty() ? null : ConsistencyLevel.valueOf(table.writeConsistency().toUpperCase());
         ConsistencyLevel readConsistency = table.readConsistency().isEmpty() ? null : ConsistencyLevel.valueOf(table.readConsistency().toUpperCase());

         if (Strings.isNullOrEmpty(table.keyspace())) {
             String loggedKeyspace = mappingManager.getSession().getLoggedKeyspace();
             if (Strings.isNullOrEmpty(loggedKeyspace))
                 throw new IllegalArgumentException(String.format(
                         "Error creating mapper for %s, the @Table annotation declares no default keyspace, and the session is not currently logged to any keyspace",
                         entityClass
                 ));
             ksName = Metadata.quote(loggedKeyspace);
         }

         KeyspaceMetadata keyspaceMetadata = mappingManager.getSession().getCluster().getMetadata().getKeyspace(ksName);
         if (keyspaceMetadata == null)
             throw new IllegalArgumentException(String.format("Keyspace %s does not exist", ksName));

         AbstractTableMetadata tableMetadata = keyspaceMetadata.getTable(tableName);
         if (tableMetadata == null) {
             tableMetadata = keyspaceMetadata.getMaterializedView(tableName);
             if (tableMetadata == null)
                 throw new IllegalArgumentException(String.format("Table or materialized view %s does not exist in keyspace %s", tableName, ksName));
         }

         EntityMapper<T> mapper = new EntityMapper<T>(entityClass, ksName, tableName, writeConsistency, readConsistency);

         List<AliasedMappedProperty<?>> pks = new ArrayList<AliasedMappedProperty<?>>();
         List<AliasedMappedProperty<?>> ccs = new ArrayList<AliasedMappedProperty<?>>();
         List<AliasedMappedProperty<?>> rgs = new ArrayList<AliasedMappedProperty<?>>();

         MappingConfiguration configuration = mappingManager.getConfiguration();
         Set<? extends MappedProperty<?>> properties = configuration.getPropertyMapper().mapTable(entityClass);
         AtomicInteger columnCounter = mappingManager.isCassandraV1 ? null : new AtomicInteger(0);

         for (MappedProperty<?> mappedProperty : properties) {

             String alias = (columnCounter != null)
                     ? "col" + columnCounter.incrementAndGet()
                     : null;

             AliasedMappedProperty<?> aliasedMappedProperty = new AliasedMappedProperty(mappedProperty, alias);

             if (mappingManager.isCassandraV1 && mappedProperty.isComputed())
                 throw new UnsupportedOperationException("Computed properties are not supported with native protocol v1");

             if (!mappedProperty.isComputed() && tableMetadata.getColumn(mappedProperty.getMappedName()) == null)
                 throw new IllegalArgumentException(String.format("Column %s does not exist in table %s.%s",
                         mappedProperty.getMappedName(), ksName, tableName));

             if (mappedProperty.isPartitionKey())
                 pks.add(aliasedMappedProperty);
             else if (mappedProperty.isClusteringColumn())
                 ccs.add(aliasedMappedProperty);
             else
                 rgs.add(aliasedMappedProperty);

             // if the property is of a UDT type, parse it now
             for (Class<?> udt : TypeMappings.findUDTs(mappedProperty.getPropertyType().getType()))
                 mappingManager.getUDTCodec(udt);
         }

         Collections.sort(pks, POSITION_COMPARATOR);
         Collections.sort(ccs, POSITION_COMPARATOR);

         AnnotationChecks.validateOrder(pks, "@PartitionKey");
         AnnotationChecks.validateOrder(ccs, "@ClusteringColumn");

         mapper.addColumns(pks, ccs, rgs);
         return mapper;
     }

     static <T> MappedUDTCodec<T> parseUDT(Class<T> udtClass, MappingManager mappingManager) {
         UDT udt = AnnotationChecks.getTypeAnnotation(UDT.class, udtClass);

         String ksName = udt.caseSensitiveKeyspace() ? Metadata.quote(udt.keyspace()) : udt.keyspace().toLowerCase();
         String udtName = udt.caseSensitiveType() ? Metadata.quote(udt.name()) : udt.name().toLowerCase();

         if (Strings.isNullOrEmpty(udt.keyspace())) {
             String loggedKeyspace = mappingManager.getSession().getLoggedKeyspace();
             if (Strings.isNullOrEmpty(loggedKeyspace))
                 throw new IllegalArgumentException(String.format(
                         "Error creating UDT codec for %s, the @UDT annotation declares no default keyspace, and the session is not currently logged to any keyspace",
                         udtClass
                 ));
             ksName = Metadata.quote(loggedKeyspace);
         }

         KeyspaceMetadata keyspaceMetadata = mappingManager.getSession().getCluster().getMetadata().getKeyspace(ksName);
         if (keyspaceMetadata == null)
             throw new IllegalArgumentException(String.format("Keyspace %s does not exist", ksName));

         UserType userType = keyspaceMetadata.getUserType(udtName);
         if (userType == null)
             throw new IllegalArgumentException(String.format("User type %s does not exist in keyspace %s", udtName, ksName));

         Map<String, AliasedMappedProperty<?>> propertyMappers = new HashMap<String, AliasedMappedProperty<?>>();

         MappingConfiguration configuration = mappingManager.getConfiguration();
         Set<? extends MappedProperty<?>> properties = configuration.getPropertyMapper().mapUdt(udtClass);

         for (MappedProperty<?> mappedProperty : properties) {

             AliasedMappedProperty<?> aliasedMappedProperty = new AliasedMappedProperty(mappedProperty, null);

             if (!userType.contains(mappedProperty.getMappedName()))
                 throw new IllegalArgumentException(String.format("Field %s does not exist in type %s.%s",
                         mappedProperty.getMappedName(), ksName, userType.getTypeName()));

             for (Class<?> fieldUdt : TypeMappings.findUDTs(mappedProperty.getPropertyType().getType()))
                 mappingManager.getUDTCodec(fieldUdt);

             propertyMappers.put(mappedProperty.getMappedName(), aliasedMappedProperty);
         }

         return new MappedUDTCodec<T>(userType, udtClass, propertyMappers, mappingManager);
     }

     static <T> AccessorMapper<T> parseAccessor(Class<T> accClass, MappingManager mappingManager) {
         if (!accClass.isInterface())
             throw new IllegalArgumentException("@Accessor annotation is only allowed on interfaces, got " + accClass);

         AnnotationChecks.getTypeAnnotation(Accessor.class, accClass);

         List<MethodMapper> methods = new ArrayList<MethodMapper>();
         for (Method m : accClass.getDeclaredMethods()) {
             Query query = m.getAnnotation(Query.class);
             if (query == null)
                 continue;

             String queryString = query.value();

             Annotation[][] paramAnnotations = m.getParameterAnnotations();
             Type[] paramTypes = m.getGenericParameterTypes();
             ParamMapper[] paramMappers = new ParamMapper[paramAnnotations.length];
             Boolean allParamsNamed = null;
             for (int i = 0; i < paramMappers.length; i++) {
                 String paramName = null;
                 Class<? extends TypeCodec<?>> codecClass = null;
                 for (Annotation a : paramAnnotations[i]) {
                     if (a.annotationType().equals(Param.class)) {
                         Param param = (Param) a;
                         paramName = param.value();
                         if (paramName.isEmpty())
                             paramName = null;
                         codecClass = param.codec();
                         if (Defaults.NoCodec.class.equals(codecClass))
                             codecClass = null;
                         break;
                     }
                 }
                 boolean thisParamNamed = (paramName != null);
                 if (allParamsNamed == null)
                     allParamsNamed = thisParamNamed;
                 else if (allParamsNamed != thisParamNamed)
                     throw new IllegalArgumentException(String.format("For method '%s', either all or none of the parameters must be named", m.getName()));

                 paramMappers[i] = newParamMapper(accClass.getName(), m.getName(), i, paramName, codecClass, paramTypes[i], mappingManager);
             }

             ConsistencyLevel cl = null;
             int fetchSize = -1;
             boolean tracing = false;
             Boolean idempotent = null;

             QueryParameters options = m.getAnnotation(QueryParameters.class);
             if (options != null) {
                 cl = options.consistency().isEmpty() ? null : ConsistencyLevel.valueOf(options.consistency().toUpperCase());
                 fetchSize = options.fetchSize();
                 tracing = options.tracing();
                 if (options.idempotent().length > 1) {
                     throw new IllegalArgumentException("idemtpotence() attribute can only accept one value");
                 }
                 idempotent = options.idempotent().length == 0 ? null : options.idempotent()[0];
             }

             methods.add(new MethodMapper(m, queryString, paramMappers, cl, fetchSize, tracing, idempotent));
         }

         return new AccessorMapper<T>(accClass, methods);
     }

     private static ParamMapper newParamMapper(String className, String methodName, int idx, String paramName, Class<? extends TypeCodec<?>> codecClass, Type paramType, MappingManager mappingManager) {
         if (paramType instanceof Class) {
             Class<?> paramClass = (Class<?>) paramType;
             if (TypeMappings.isMappedUDT(paramClass))
                 mappingManager.getUDTCodec(paramClass);

             return new ParamMapper(paramName, idx, TypeToken.of(paramType), codecClass);
         } else if (paramType instanceof ParameterizedType) {
             for (Class<?> udt : TypeMappings.findUDTs(paramType))
                 mappingManager.getUDTCodec(udt);

             return new ParamMapper(paramName, idx, TypeToken.of(paramType), codecClass);
         } else {
             throw new IllegalArgumentException(String.format("Cannot map class %s for parameter %s of %s.%s", paramType, paramName, className, methodName));
         }
     }
 }
	/*
	* Copyright (C) 2012-2015 DataStax Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.datastax.driver.mapping;

	import com.datastax.driver.core.*;
	import com.datastax.driver.mapping.MethodMapper.ParamMapper;
	import com.datastax.driver.mapping.annotations.*;
	import com.google.common.base.Strings;
	import com.google.common.reflect.TypeToken;

	import java.lang.annotation.Annotation;
	import java.lang.reflect.Method;
	import java.lang.reflect.ParameterizedType;
	import java.lang.reflect.Type;
	import java.util.*;
	import java.util.concurrent.atomic.AtomicInteger;

	/**
	* Static methods that facilitates parsing:
	* - {@link #parseEntity(Class, MappingManager)}: entity classes into {@link EntityMapper} instances
	* - {@link #parseUDT(Class, MappingManager)}: UDT classes into {@link MappedUDTCodec} instances.
	* - {@link #parseAccessor(Class, MappingManager)}: Accessor interfaces into {@link AccessorMapper} instances.
	*/
	class AnnotationParser {

	private static final Comparator<AliasedMappedProperty<?>> POSITION_COMPARATOR = new Comparator<AliasedMappedProperty<?>>() {
	@Override
	public int compare(AliasedMappedProperty<?> o1, AliasedMappedProperty<?> o2) {
	return o1.mappedProperty.getPosition() - o2.mappedProperty.getPosition();
	}
	};

	private AnnotationParser() {
	}

	static <T> EntityMapper<T> parseEntity(final Class<T> entityClass, MappingManager mappingManager) {
	Table table = AnnotationChecks.getTypeAnnotation(Table.class, entityClass);

	String ksName = table.caseSensitiveKeyspace() ? Metadata.quote(table.keyspace()) : table.keyspace().toLowerCase();
	String tableName = table.caseSensitiveTable() ? Metadata.quote(table.name()) : table.name().toLowerCase();

	ConsistencyLevel writeConsistency = table.writeConsistency().isEmpty() ? null : ConsistencyLevel.valueOf(table.writeConsistency().toUpperCase());
	ConsistencyLevel readConsistency = table.readConsistency().isEmpty() ? null : ConsistencyLevel.valueOf(table.readConsistency().toUpperCase());

	if (Strings.isNullOrEmpty(table.keyspace())) {
	String loggedKeyspace = mappingManager.getSession().getLoggedKeyspace();
	if (Strings.isNullOrEmpty(loggedKeyspace))
	throw new IllegalArgumentException(String.format(
	"Error creating mapper for %s, the @Table annotation declares no default keyspace, and the session is not currently logged to any keyspace",
	entityClass
	));
	ksName = Metadata.quote(loggedKeyspace);
	}

	KeyspaceMetadata keyspaceMetadata = mappingManager.getSession().getCluster().getMetadata().getKeyspace(ksName);
	if (keyspaceMetadata == null)
	throw new IllegalArgumentException(String.format("Keyspace %s does not exist", ksName));

	AbstractTableMetadata tableMetadata = keyspaceMetadata.getTable(tableName);
	if (tableMetadata == null) {
	tableMetadata = keyspaceMetadata.getMaterializedView(tableName);
	if (tableMetadata == null)
	throw new IllegalArgumentException(String.format("Table or materialized view %s does not exist in keyspace %s", tableName, ksName));
	}

	EntityMapper<T> mapper = new EntityMapper<T>(entityClass, ksName, tableName, writeConsistency, readConsistency);

	List<AliasedMappedProperty<?>> pks = new ArrayList<AliasedMappedProperty<?>>();
	List<AliasedMappedProperty<?>> ccs = new ArrayList<AliasedMappedProperty<?>>();
	List<AliasedMappedProperty<?>> rgs = new ArrayList<AliasedMappedProperty<?>>();

	MappingConfiguration configuration = mappingManager.getConfiguration();
	Set<? extends MappedProperty<?>> properties = configuration.getPropertyMapper().mapTable(entityClass);
	AtomicInteger columnCounter = mappingManager.isCassandraV1 ? null : new AtomicInteger(0);

	for (MappedProperty<?> mappedProperty : properties) {

	String alias = (columnCounter != null)
	? "col" + columnCounter.incrementAndGet()
	: null;

	AliasedMappedProperty<?> aliasedMappedProperty = new AliasedMappedProperty(mappedProperty, alias);

	if (mappingManager.isCassandraV1 && mappedProperty.isComputed())
	throw new UnsupportedOperationException("Computed properties are not supported with native protocol v1");

	if (!mappedProperty.isComputed() && tableMetadata.getColumn(mappedProperty.getMappedName()) == null)
	throw new IllegalArgumentException(String.format("Column %s does not exist in table %s.%s",
	mappedProperty.getMappedName(), ksName, tableName));

	if (mappedProperty.isPartitionKey())
	pks.add(aliasedMappedProperty);
	else if (mappedProperty.isClusteringColumn())
	ccs.add(aliasedMappedProperty);
	else
	rgs.add(aliasedMappedProperty);

	// if the property is of a UDT type, parse it now
	for (Class<?> udt : TypeMappings.findUDTs(mappedProperty.getPropertyType().getType()))
	mappingManager.getUDTCodec(udt);
	}

	Collections.sort(pks, POSITION_COMPARATOR);
	Collections.sort(ccs, POSITION_COMPARATOR);

	AnnotationChecks.validateOrder(pks, "@PartitionKey");
	AnnotationChecks.validateOrder(ccs, "@ClusteringColumn");

	mapper.addColumns(pks, ccs, rgs);
	return mapper;
	}

	static <T> MappedUDTCodec<T> parseUDT(Class<T> udtClass, MappingManager mappingManager) {
	UDT udt = AnnotationChecks.getTypeAnnotation(UDT.class, udtClass);

	String ksName = udt.caseSensitiveKeyspace() ? Metadata.quote(udt.keyspace()) : udt.keyspace().toLowerCase();
	String udtName = udt.caseSensitiveType() ? Metadata.quote(udt.name()) : udt.name().toLowerCase();

	if (Strings.isNullOrEmpty(udt.keyspace())) {
	String loggedKeyspace = mappingManager.getSession().getLoggedKeyspace();
	if (Strings.isNullOrEmpty(loggedKeyspace))
	throw new IllegalArgumentException(String.format(
	"Error creating UDT codec for %s, the @UDT annotation declares no default keyspace, and the session is not currently logged to any keyspace",
	udtClass
	));
	ksName = Metadata.quote(loggedKeyspace);
	}

	KeyspaceMetadata keyspaceMetadata = mappingManager.getSession().getCluster().getMetadata().getKeyspace(ksName);
	if (keyspaceMetadata == null)
	throw new IllegalArgumentException(String.format("Keyspace %s does not exist", ksName));

	UserType userType = keyspaceMetadata.getUserType(udtName);
	if (userType == null)
	throw new IllegalArgumentException(String.format("User type %s does not exist in keyspace %s", udtName, ksName));

	Map<String, AliasedMappedProperty<?>> propertyMappers = new HashMap<String, AliasedMappedProperty<?>>();

	MappingConfiguration configuration = mappingManager.getConfiguration();
	Set<? extends MappedProperty<?>> properties = configuration.getPropertyMapper().mapUdt(udtClass);

	for (MappedProperty<?> mappedProperty : properties) {

	AliasedMappedProperty<?> aliasedMappedProperty = new AliasedMappedProperty(mappedProperty, null);

	if (!userType.contains(mappedProperty.getMappedName()))
	throw new IllegalArgumentException(String.format("Field %s does not exist in type %s.%s",
	mappedProperty.getMappedName(), ksName, userType.getTypeName()));

	for (Class<?> fieldUdt : TypeMappings.findUDTs(mappedProperty.getPropertyType().getType()))
	mappingManager.getUDTCodec(fieldUdt);

	propertyMappers.put(mappedProperty.getMappedName(), aliasedMappedProperty);
	}

	return new MappedUDTCodec<T>(userType, udtClass, propertyMappers, mappingManager);
	}

	static <T> AccessorMapper<T> parseAccessor(Class<T> accClass, MappingManager mappingManager) {
	if (!accClass.isInterface())
	throw new IllegalArgumentException("@Accessor annotation is only allowed on interfaces, got " + accClass);

	AnnotationChecks.getTypeAnnotation(Accessor.class, accClass);

	List<MethodMapper> methods = new ArrayList<MethodMapper>();
	for (Method m : accClass.getDeclaredMethods()) {
	Query query = m.getAnnotation(Query.class);
	if (query == null)
	continue;

	String queryString = query.value();

	Annotation[][] paramAnnotations = m.getParameterAnnotations();
	Type[] paramTypes = m.getGenericParameterTypes();
	ParamMapper[] paramMappers = new ParamMapper[paramAnnotations.length];
	Boolean allParamsNamed = null;
	for (int i = 0; i < paramMappers.length; i++) {
	String paramName = null;
	Class<? extends TypeCodec<?>> codecClass = null;
	for (Annotation a : paramAnnotations[i]) {
	if (a.annotationType().equals(Param.class)) {
	Param param = (Param) a;
	paramName = param.value();
	if (paramName.isEmpty())
	paramName = null;
	codecClass = param.codec();
	if (Defaults.NoCodec.class.equals(codecClass))
	codecClass = null;
	break;
	}
	}
	boolean thisParamNamed = (paramName != null);
	if (allParamsNamed == null)
	allParamsNamed = thisParamNamed;
	else if (allParamsNamed != thisParamNamed)
	throw new IllegalArgumentException(String.format("For method '%s', either all or none of the parameters must be named", m.getName()));

	paramMappers[i] = newParamMapper(accClass.getName(), m.getName(), i, paramName, codecClass, paramTypes[i], mappingManager);
	}

	ConsistencyLevel cl = null;
	int fetchSize = -1;
	boolean tracing = false;
	Boolean idempotent = null;

	QueryParameters options = m.getAnnotation(QueryParameters.class);
	if (options != null) {
	cl = options.consistency().isEmpty() ? null : ConsistencyLevel.valueOf(options.consistency().toUpperCase());
	fetchSize = options.fetchSize();
	tracing = options.tracing();
	if (options.idempotent().length > 1) {
	throw new IllegalArgumentException("idemtpotence() attribute can only accept one value");
	}
	idempotent = options.idempotent().length == 0 ? null : options.idempotent()[0];
	}

	methods.add(new MethodMapper(m, queryString, paramMappers, cl, fetchSize, tracing, idempotent));
	}

	return new AccessorMapper<T>(accClass, methods);
	}

	private static ParamMapper newParamMapper(String className, String methodName, int idx, String paramName, Class<? extends TypeCodec<?>> codecClass, Type paramType, MappingManager mappingManager) {
	if (paramType instanceof Class) {
	Class<?> paramClass = (Class<?>) paramType;
	if (TypeMappings.isMappedUDT(paramClass))
	mappingManager.getUDTCodec(paramClass);

	return new ParamMapper(paramName, idx, TypeToken.of(paramType), codecClass);
	} else if (paramType instanceof ParameterizedType) {
	for (Class<?> udt : TypeMappings.findUDTs(paramType))
	mappingManager.getUDTCodec(udt);

	return new ParamMapper(paramName, idx, TypeToken.of(paramType), codecClass);
	} else {
	throw new IllegalArgumentException(String.format("Cannot map class %s for parameter %s of %s.%s", paramType, paramName, className, methodName));
	}
	}
	}