github/jooq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[#4403] A Field's coerced data type is not taken into account when calling Result.intoMap(Field, Class)

Browse Source
This commit is contained in:
lukaseder 2015-09-15 15:50:28 +02:00
parent be6f0be93f
commit 2ab84244cd
2 changed files with 28 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java
View File

@ -220,7 +220,7 @@ abstract class AbstractRecord extends AbstractStore implements Record {
@Override
public final <T> T getValue(Field<T> field) {
return (T) getValue(indexOrFail(fieldsRow(), field));
return getValue(indexOrFail(fieldsRow(), field), field.getConverter());
}
@Override

53
jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
View File

@ -43,6 +43,7 @@ package org.jooq.impl;
import static java.lang.Math.max;
import static java.lang.Math.min;
import static org.jooq.Converters.identity;
import static org.jooq.impl.DSL.insertInto;
import static org.jooq.impl.DSL.name;
import static org.jooq.impl.DSL.table;
@ -318,7 +319,7 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
@Override
public final <T> List<T> getValues(Field<T> field) {
return (List<T>) getValues(indexOrFail(fieldsRow(), field));
return getValues(indexOrFail(fieldsRow(), field), field.getConverter());
}
@Override
@ -1166,12 +1167,12 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
@Override
public final <K> Map<K, R> intoMap(Field<K> key) {
return intoMap0(indexOrFail(fieldsRow(), key));
return intoMap0(indexOrFail(fieldsRow(), key), key.getConverter());
}
@Override
public final Map<?, R> intoMap(int keyFieldIndex) {
return intoMap0(keyFieldIndex);
return intoMap0(keyFieldIndex, identity(Object.class));
}
@Override
@ -1184,11 +1185,11 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
return intoMap(field(keyFieldName));
}
private final <K> Map<K, R> intoMap0(int keyFieldIndex) {
private final <K> Map<K, R> intoMap0(int keyFieldIndex, Converter<?, K> keyConverter) {
Map<K, R> map = new LinkedHashMap<K, R>();
for (R record : this)
if (map.put((K) record.getValue(keyFieldIndex), record) != null)
if (map.put(record.getValue(keyFieldIndex, keyConverter), record) != null)
throw new InvalidResultException("Key " + keyFieldIndex + " is not unique in Result for " + this);
return map;
@ -1199,12 +1200,12 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
int kIndex = indexOrFail(fieldsRow(), key);
int vIndex = indexOrFail(fieldsRow(), value);
return intoMap0(kIndex, vIndex);
return intoMap0(kIndex, key.getConverter(), vIndex, value.getConverter());
}
@Override
public final Map<?, ?> intoMap(int keyFieldIndex, int valueFieldIndex) {
return intoMap0(keyFieldIndex, valueFieldIndex);
return intoMap0(keyFieldIndex, identity(Object.class), valueFieldIndex, identity(Object.class));
}
@Override
@ -1217,11 +1218,11 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
return intoMap(field(keyFieldName), field(valueFieldName));
}
private final <K, V> Map<K, V> intoMap0(int kIndex, int vIndex) {
private final <K, V> Map<K, V> intoMap0(int kIndex, Converter<?, K> kConverter, int vIndex, Converter<?, V> vConverter) {
Map<K, V> map = new LinkedHashMap<K, V>();
for (R record : this)
if (map.put((K) record.getValue(kIndex), (V) record.getValue(vIndex)) != null)
if (map.put(record.getValue(kIndex, kConverter), record.getValue(vIndex, vConverter)) != null)
throw new InvalidResultException("Key " + kIndex + " is not unique in Result for " + this);
return map;
@ -1428,7 +1429,7 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
@Override
public final <E> Map<?, E> intoMap(int keyFieldIndex, RecordMapper<? super R, E> mapper) {
return intoMap0(keyFieldIndex, mapper);
return intoMap0(keyFieldIndex, identity(Object.class), mapper);
}
@Override
@ -1443,14 +1444,14 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
@Override
public final <K, E> Map<K, E> intoMap(Field<K> key, RecordMapper<? super R, E> mapper) {
return intoMap0(indexOrFail(fieldsRow(), key), mapper);
return intoMap0(indexOrFail(fieldsRow(), key), key.getConverter(), mapper);
}
private final <K, E> Map<K, E> intoMap0(int keyFieldIndex, RecordMapper<? super R, E> mapper) {
private final <K, E> Map<K, E> intoMap0(int keyFieldIndex, Converter<?, K> keyConverter, RecordMapper<? super R, E> mapper) {
Map<K, E> map = new LinkedHashMap<K, E>();
for (R record : this)
if (map.put((K) record.getValue(keyFieldIndex), mapper.map(record)) != null)
if (map.put(record.getValue(keyFieldIndex, keyConverter), mapper.map(record)) != null)
throw new InvalidResultException("Key " + keyFieldIndex + " is not unique in Result for " + this);
return map;
@ -1458,12 +1459,12 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
@Override
public final <K> Map<K, Result<R>> intoGroups(Field<K> key) {
return intoGroups0(indexOrFail(fieldsRow(), key));
return intoGroups0(indexOrFail(fieldsRow(), key), key.getConverter());
}
@Override
public final Map<?, Result<R>> intoGroups(int keyFieldIndex) {
return intoGroups0(keyFieldIndex);
return intoGroups0(keyFieldIndex, identity(Object.class));
}
@Override
@ -1476,11 +1477,11 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
return intoGroups(field(keyFieldName));
}
private final <K> Map<K, Result<R>> intoGroups0(int keyFieldIndex) {
private final <K> Map<K, Result<R>> intoGroups0(int keyFieldIndex, Converter<?, K> keyConverter) {
Map<K, Result<R>> map = new LinkedHashMap<K, Result<R>>();
for (R record : this) {
K val = (K) record.getValue(keyFieldIndex);
K val = record.getValue(keyFieldIndex, keyConverter);
Result<R> result = map.get(val);
if (result == null) {
@ -1499,12 +1500,12 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
int kIndex = indexOrFail(fieldsRow(), key);
int vIndex = indexOrFail(fieldsRow(), value);
return intoGroups0(kIndex, vIndex);
return intoGroups0(kIndex, key.getConverter(), vIndex, value.getConverter());
}
@Override
public final Map<?, List<?>> intoGroups(int keyFieldIndex, int valueFieldIndex) {
return (Map) intoGroups0(keyFieldIndex, valueFieldIndex);
return (Map) intoGroups0(keyFieldIndex, identity(Object.class), valueFieldIndex, identity(Object.class));
}
@Override
@ -1517,12 +1518,12 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
return (Map) intoGroups(field(keyFieldName), field(valueFieldName));
}
private final <K, V> Map<K, List<V>> intoGroups0(int kIndex, int vIndex) {
private final <K, V> Map<K, List<V>> intoGroups0(int kIndex, Converter<?, K> kConverter, int vIndex, Converter<?, V> vConverter) {
Map<K, List<V>> map = new LinkedHashMap<K, List<V>>();
for (R record : this) {
K k = (K) record.getValue(kIndex);
V v = (V) record.getValue(vIndex);
K k = record.getValue(kIndex, kConverter);
V v = record.getValue(vIndex, vConverter);
List<V> result = map.get(k);
if (result == null) {
@ -1558,12 +1559,12 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
@Override
public final <K, E> Map<K, List<E>> intoGroups(Field<K> key, RecordMapper<? super R, E> mapper) {
return intoGroups0(indexOrFail(fieldsRow(), key), mapper);
return intoGroups0(indexOrFail(fieldsRow(), key), key.getConverter(), mapper);
}
@Override
public final <E> Map<?, List<E>> intoGroups(int keyFieldIndex, RecordMapper<? super R, E> mapper) {
return intoGroups0(keyFieldIndex, mapper);
return intoGroups0(keyFieldIndex, identity(Object.class), mapper);
}
@Override
@ -1576,11 +1577,11 @@ class ResultImpl<R extends Record> implements Result<R>, AttachableInternal {
return intoGroups(field(keyFieldName), mapper);
}
private final <K, E> Map<K, List<E>> intoGroups0(int keyFieldIndex, RecordMapper<? super R, E> mapper) {
private final <K, E> Map<K, List<E>> intoGroups0(int keyFieldIndex, Converter<?, K> keyConverter, RecordMapper<? super R, E> mapper) {
Map<K, List<E>> map = new LinkedHashMap<K, List<E>>();
for (R record : this) {
K keyVal = (K) record.getValue(keyFieldIndex);
K keyVal = record.getValue(keyFieldIndex, keyConverter);
List<E> list = map.get(keyVal);
if (list == null) {