From 2ab84244cd7b443c10fa92659cef665c7eef3d41 Mon Sep 17 00:00:00 2001
From: lukaseder <lukas.eder@gmail.com>
Date: Tue, 15 Sep 2015 15:50:28 +0200
Subject: [PATCH] [#4403] A Field's coerced data type is not taken into account
 when calling Result.intoMap(Field, Class)

---
 .../java/org/jooq/impl/AbstractRecord.java    |  2 +-
 .../main/java/org/jooq/impl/ResultImpl.java   | 53 ++++++++++---------
 2 files changed, 28 insertions(+), 27 deletions(-)

diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java b/jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java
index 550ba49e18..2e97dc1e49 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractRecord.java
@@ -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
diff --git a/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java b/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
index 07f042379d..ee439ecfa8 100644
--- a/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/ResultImpl.java
@@ -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) {