if (dataType.equals(DataType.map(firstArg, secondArg))) { return row.getMap(i, firstCodec.getJavaType(), secondCodec.getJavaType());
String secondParamTypeName = matcher.group(5); DataType secondParamType = getPrimitiveDataTypeFromString(secondParamTypeName); DataType mapType = DataType.map(firstParamType, secondParamType); statement.setMap(paramIndex, (Map) codecRegistry.codecFor(mapType).parse(paramValue)); return;
/** * Returns the type of "not frozen" maps of {@code keyType} to {@code valueType} elements. * * <p>This is a shorthand for {@code map(keyType, valueType, false);}. * * @param keyType the type of the map keys. * @param valueType the type of the map values. * @return the type of "not frozen" maps of {@code keyType} to {@code valueType} elements. */ public static CollectionType map(DataType keyType, DataType valueType) { return map(keyType, valueType, false); }
/** * Returns the type of frozen maps of {@code keyType} to {@code valueType} elements. * * <p>This is a shorthand for {@code map(keyType, valueType, true);}. * * @param keyType the type of the map keys. * @param valueType the type of the map values. * @return the type of frozen maps of {@code keyType} to {@code valueType} elements. */ public static CollectionType frozenMap(DataType keyType, DataType valueType) { return map(keyType, valueType, true); }
private static void createTableIfNotExists(final com.datastax.driver.core.Session session, final String table, final Logger log) { Create createTable = SchemaBuilder.createTable(table) .addPartitionKey(ID, DataType.varchar()) .addColumn(CREATED_AT, DataType.timestamp()) .addColumn(ACCESSED_AT, DataType.timestamp()) .addColumn(SAVED_AT, DataType.timestamp()) .addColumn(ATTRIBUTES, DataType.map(DataType.varchar(), DataType.varchar())) .ifNotExists(); Futures.addCallback(session.executeAsync(createTable), new FutureCallback<ResultSet>() { @Override public void onSuccess(final ResultSet result) { log.debug("Session table successfully created"); } @Override public void onFailure(final Throwable x) { log.error("Create session table resulted in exception", x); } }); }
if (dataType.equals(DataType.map(firstArg, secondArg))) { builder.name(columnDefinitions.getName(i)).type().unionOf().nullBuilder().endNull().and().map().values( getUnionFieldType(getPrimitiveAvroTypeFromCassandraType(secondArg))).endUnion().noDefault();
@Override public void init(CassandraSessionPool.Session session) { ImmutableMap<HugeKeys, DataType> pkeys = ImmutableMap.of( HugeKeys.ID, DataType.text() ); ImmutableMap<HugeKeys, DataType> ckeys = ImmutableMap.of(); ImmutableMap<HugeKeys, DataType> columns = ImmutableMap.of( HugeKeys.LABEL, DATATYPE_SL, HugeKeys.PROPERTIES, DataType.map(DATATYPE_PK, DataType.text()) ); this.createTable(session, pkeys, ckeys, columns); this.createIndex(session, LABEL_INDEX, HugeKeys.LABEL); }
private List<TestTable> tablesWithMapsOfPrimitives() { List<TestTable> tables = Lists.newArrayList(); for (Map.Entry<DataType, Object> keyEntry : samples.entrySet()) { // Duration not supported as Map key DataType keyType = keyEntry.getKey(); if (keyType == DataType.duration()) continue; Object keySample = keyEntry.getValue(); for (Map.Entry<DataType, Object> valueEntry : samples.entrySet()) { DataType valueType = valueEntry.getKey(); Object valueSample = valueEntry.getValue(); tables.add( new TestTable( DataType.map(keyType, valueType), ImmutableMap.builder().put(keySample, valueSample).build(), "1.2.0")); } } return tables; }
protected AbstractMapCodec(TypeCodec<K> keyCodec, TypeCodec<V> valueCodec) { super( DataType.map(keyCodec.getCqlType(), valueCodec.getCqlType()), TypeTokens.mapOf(keyCodec.getJavaType(), valueCodec.getJavaType())); this.keyCodec = keyCodec; this.valueCodec = valueCodec; }
@Override public void init(CassandraSessionPool.Session session) { ImmutableMap<HugeKeys, DataType> pkeys = ImmutableMap.of( HugeKeys.OWNER_VERTEX, DataType.text() ); ImmutableMap<HugeKeys, DataType> ckeys = ImmutableMap.of( HugeKeys.DIRECTION, DataType.tinyint(), HugeKeys.LABEL, DATATYPE_SL, HugeKeys.SORT_VALUES, DataType.text(), HugeKeys.OTHER_VERTEX, DataType.text() ); ImmutableMap<HugeKeys, DataType> columns = ImmutableMap.of( HugeKeys.PROPERTIES, DataType.map(DATATYPE_PK, DataType.text()) ); this.createTable(session, pkeys, ckeys, columns); /* * Only out-edges table needs label index because we query edges * by label from out-edges table */ if (this.direction == Directions.OUT) { this.createIndex(session, LABEL_INDEX, HugeKeys.LABEL); } }
@Test(groups = "unit") public void testCustomValueMap() throws Exception { DataType cqlType = map(text(), CUSTOM_FOO); TypeCodec<Map<?, ?>> codec = codecRegistry.codecFor(cqlType); assertThat(codec).isNotNull().accepts(cqlType); }
@Test(groups = "unit") public void testCustomKeyMap() throws Exception { DataType cqlType = map(CUSTOM_FOO, text()); TypeCodec<Map<?, ?>> codec = codecRegistry.codecFor(cqlType); assertThat(codec).isNotNull().accepts(cqlType); }
@Test(groups = "unit") public void should_create_simple_table_with_map() throws Exception { // When SchemaStatement statement = createTable("test") .addPartitionKey("id", DataType.bigint()) .addColumn("friends", DataType.map(DataType.cint(), DataType.text())); // Then assertThat(statement.getQueryString()) .isEqualTo( "\n\tCREATE TABLE test(\n\t\t" + "id bigint,\n\t\t" + "friends map<int, text>,\n\t\t" + "PRIMARY KEY(id))"); }
@SuppressWarnings("serial") @Test(groups = "unit") public void parseFormatMapTest() { String toParse = "{'Foo':3,'Bar':42,'Foo''bar':-24}"; Map<String, Integer> toFormat = new LinkedHashMap<String, Integer>() { { put("Foo", 3); put("Bar", 42); put("Foo'bar", -24); } }; DataType dt = DataType.map(DataType.text(), DataType.cint()); assertEquals(codecRegistry.codecFor(dt).parse(toParse), toFormat); assertEquals(codecRegistry.codecFor(dt).format(toFormat), toParse); }
/** * Validates that columns using collections of custom types are properly handled by the driver. * * @jira_ticket JAVA-1034 * @test_category metadata */ @Test(groups = "short") public void should_serialize_and_deserialize_collections_of_custom_types() { TestUtils.compactStorageSupportCheck(ccm()); TableMetadata table = cluster().getMetadata().getKeyspace(keyspace).getTable("test_collection"); assertThat(table.getColumn("c1")).hasType(DataType.list(CUSTOM_DYNAMIC_COMPOSITE)); assertThat(table.getColumn("c2")) .hasType(DataType.map(CUSTOM_DYNAMIC_COMPOSITE, CUSTOM_DYNAMIC_COMPOSITE)); session() .execute( "INSERT INTO test_collection(k, c1, c2) VALUES (0, [ 's@foo:i@32' ], { 's@foo:i@32': 's@bar:i@42' })"); Row r = session().execute("SELECT * FROM test_collection").one(); assertThat(r.getColumnDefinitions().getType("c1")) .isEqualTo(DataType.list(CUSTOM_DYNAMIC_COMPOSITE)); List<ByteBuffer> c1 = r.getList("c1", ByteBuffer.class); assertThat(c1.get(0)).isEqualTo(serializeForDynamicCompositeType("foo", 32)); assertThat(r.getColumnDefinitions().getType("c2")) .isEqualTo(DataType.map(CUSTOM_DYNAMIC_COMPOSITE, CUSTOM_DYNAMIC_COMPOSITE)); Map<ByteBuffer, ByteBuffer> c2 = r.getMap("c2", ByteBuffer.class, ByteBuffer.class); Map.Entry<ByteBuffer, ByteBuffer> entry = c2.entrySet().iterator().next(); assertThat(entry.getKey()).isEqualTo(serializeForDynamicCompositeType("foo", 32)); assertThat(entry.getValue()).isEqualTo(serializeForDynamicCompositeType("bar", 42)); }
@Test(groups = "short") public void should_ignore_whitespace() { assertThat(parse(" int ", cluster(), null, null, null, false, false)).isEqualTo(cint()); assertThat(parse(" set < bigint > ", cluster(), null, null, null, false, false)) .isEqualTo(set(bigint())); assertThat(parse(" map < date , timeuuid > ", cluster(), null, null, null, false, false)) .isEqualTo(map(date(), timeuuid())); }
@Test(groups = "short") public void should_parse_frozen_collection_types() { assertThat(parse("frozen<list<int>>", cluster(), null, null, null, false, false)) .isEqualTo(list(cint(), true)); assertThat(parse("frozen<set<bigint>>", cluster(), null, null, null, false, false)) .isEqualTo(set(bigint(), true)); assertThat(parse("frozen<map<date,timeuuid>>", cluster(), null, null, null, false, false)) .isEqualTo(map(date(), timeuuid(), true)); }
@Test(groups = "short") public void should_parse_collection_types() { assertThat(parse("list<int>", cluster(), null, null, null, false, false)) .isEqualTo(list(cint())); assertThat(parse("set<bigint>", cluster(), null, null, null, false, false)) .isEqualTo(set(bigint())); assertThat(parse("map<date,timeuuid>", cluster(), null, null, null, false, false)) .isEqualTo(map(date(), timeuuid())); }
@Test(groups = "short") public void should_ignore_case() { assertThat(parse("INT", cluster(), null, null, null, false, false)).isEqualTo(cint()); assertThat(parse("SET<BIGint>", cluster(), null, null, null, false, false)) .isEqualTo(set(bigint())); assertThat( parse("FROZEN<mAp<Date,Tuple<timeUUID>>>", cluster(), null, null, null, false, false)) .isEqualTo(map(date(), cluster().getMetadata().newTupleType(timeuuid()), true)); }
@Test(groups = "short") public void should_parse_nested_collection_types() { Metadata metadata = cluster().getMetadata(); KeyspaceMetadata keyspaceMetadata = metadata.getKeyspace(this.keyspace); assertThat(parse("list<list<int>>", cluster(), null, null, null, false, false)) .isEqualTo(list(list(cint()))); assertThat( parse( "set<list<frozen<map<bigint,varchar>>>>", cluster(), null, null, null, false, false)) .isEqualTo(set(list(map(bigint(), varchar(), true)))); UserType keyType = keyspaceMetadata.getUserType(quote("Incr,edibly\" EvilTy<>><<><p\"e")); UserType valueType = keyspaceMetadata.getUserType(quote("A")); assertThat( parse( "map<frozen<\"Incr,edibly\"\" EvilTy<>><<><p\"\"e\">,frozen<\"A\">>", cluster(), keyspace, keyspaceMetadata.userTypes, null, false, false)) .isEqualTo(map(keyType, valueType, false)); }