@SuppressWarnings("unchecked") public <K, V> Map<K, V> getMap(int i, Class<K> keysClass, Class<V> valuesClass) { DataType type = metadata.getType(i); if (type.getName() != DataType.Name.MAP) throw new InvalidTypeException( String.format("Column %s is not of map type", metadata.getName(i))); Class<?> expectedKeysClass = type.getTypeArguments().get(0).getName().javaType; Class<?> expectedValuesClass = type.getTypeArguments().get(1).getName().javaType; if (!keysClass.isAssignableFrom(expectedKeysClass) || !valuesClass.isAssignableFrom(expectedValuesClass)) throw new InvalidTypeException( String.format( "Column %s is a map of %s->%s (CQL type %s), cannot be retrieve as a map of %s->%s", metadata.getName(i), expectedKeysClass, expectedValuesClass, type, keysClass, valuesClass)); ByteBuffer value = data.get(i); if (value == null) return Collections.<K, V>emptyMap(); return Collections.unmodifiableMap(Codec.<Map<K, V>>getCodec(type).compose(value)); }
/** Test simple statement selects for all collection data types */ @SuppressWarnings("unchecked") public void collectionSelectTest() throws Throwable { HashMap<DataType, Object> sampleValueMap; String execute_string; DataType typeArgument1; DataType typeArgument2; Row row; for (DataType dataType : COLLECTION_SELECT_STATEMENTS.keySet()) { execute_string = COLLECTION_SELECT_STATEMENTS.get(dataType); row = session.execute(execute_string).one(); sampleValueMap = (HashMap<DataType, Object>) SAMPLE_COLLECTIONS.get(dataType); typeArgument1 = dataType.getTypeArguments().get(0); if (dataType.getName() == DataType.Name.MAP) { typeArgument2 = dataType.getTypeArguments().get(1); // Create a copy of the map that is being expected HashMap<DataType, Object> sampleMap = (HashMap<DataType, Object>) sampleValueMap.get(typeArgument1); Object mapKey = SAMPLE_DATA.get(sampleMap.keySet().iterator().next()); Object mapValue = sampleMap.values().iterator().next(); HashMap<Object, Object> expectedMap = new HashMap<Object, Object>(); expectedMap.put(mapKey, mapValue); assertEquals(TestUtils.getValue(row, "k", typeArgument2), SAMPLE_DATA.get(typeArgument2)); assertEquals(TestUtils.getValue(row, "v", dataType), expectedMap); } else { Object expectedValue = sampleValueMap.get(typeArgument1); assertEquals(TestUtils.getValue(row, "k", typeArgument1), SAMPLE_DATA.get(typeArgument1)); assertEquals(TestUtils.getValue(row, "v", dataType), expectedValue); } } assertEquals(SAMPLE_COLLECTIONS.size(), 255); assertEquals(COLLECTION_SELECT_STATEMENTS.keySet().size(), SAMPLE_COLLECTIONS.size()); }
@SuppressWarnings("unchecked") public <T> Set<T> getSet(int i, Class<T> elementsClass) { DataType type = metadata.getType(i); if (type.getName() != DataType.Name.SET) throw new InvalidTypeException( String.format("Column %s is not of set type", metadata.getName(i))); Class<?> expectedClass = type.getTypeArguments().get(0).getName().javaType; if (!elementsClass.isAssignableFrom(expectedClass)) throw new InvalidTypeException( String.format( "Column %s is a set of %s (CQL type %s), cannot be retrieve as a set of %s", metadata.getName(i), expectedClass, type, elementsClass)); ByteBuffer value = data.get(i); if (value == null) return Collections.<T>emptySet(); return Collections.unmodifiableSet(Codec.<Set<T>>getCodec(type).compose(value)); }
/** Generates the insert statements that will be used in testing */ @SuppressWarnings("unchecked") private static Collection<String> getCollectionInsertStatements() { ArrayList<String> insertStatements = new ArrayList<String>(); String tableName; String key; String value; for (DataType dataType : SAMPLE_COLLECTIONS.keySet()) { HashMap<DataType, Object> sampleValueMap = (HashMap<DataType, Object>) SAMPLE_COLLECTIONS.get(dataType); // Create tableName in form of: DataType_TypeArgument[_TypeArgument] tableName = helperGenerateTableName(dataType); if (dataType.getName() == DataType.Name.MAP) { List<DataType> typeArgument = dataType.getTypeArguments(); key = helperStringifiedData(typeArgument.get(0)); value = helperStringifiedData(typeArgument.get(1)); insertStatements.add(String.format(MAP_INSERT_FORMAT, tableName, key, value)); } else if (dataType.getName() == DataType.Name.LIST) { DataType typeArgument = sampleValueMap.keySet().iterator().next(); key = helperStringifiedData(typeArgument); // Create the value to be a list of the same 5 elements value = "["; for (int i = 0; i < 5; i++) value += key + ','; value = value.substring(0, value.length() - 1) + ']'; insertStatements.add(String.format(COLLECTION_INSERT_FORMAT, tableName, key, value)); } else { DataType typeArgument = sampleValueMap.keySet().iterator().next(); key = helperStringifiedData(typeArgument); value = '{' + key + '}'; insertStatements.add(String.format(COLLECTION_INSERT_FORMAT, tableName, key, value)); } } return insertStatements; }
@SuppressWarnings("unchecked") public <T> List<T> getList(int i, Class<T> elementsClass) { DataType type = metadata.getType(i); if (type.getName() != DataType.Name.LIST) throw new InvalidTypeException( String.format("Column %s is not of list type", metadata.getName(i))); Class<?> expectedClass = type.getTypeArguments().get(0).getName().javaType; if (!elementsClass.isAssignableFrom(expectedClass)) throw new InvalidTypeException( String.format( "Column %s is a list of %s (CQL type %s), cannot be retrieve as a list of %s", metadata.getName(i), expectedClass, type, elementsClass)); ByteBuffer value = data.get(i); if (value == null) return Collections.<T>emptyList(); // TODO: we could avoid the getCodec call if we kept a reference to the original message. return Collections.unmodifiableList(Codec.<List<T>>getCodec(type).compose(value)); }
/** Helper method to generate table names in the form of: DataType_TypeArgument[_TypeArgument] */ private static String helperGenerateTableName(DataType dataType) { String tableName = dataType.getName().toString(); for (DataType typeArgument : dataType.getTypeArguments()) tableName += "_" + typeArgument; return tableName; }