@Override
public final E map(R record) {
try {
for (int i = 0; i < fields.length; i++) {
if (propertyIndexes[i] != null) {
parameterValues[propertyIndexes[i]] = record.getValue(i);
} else {
for (java.lang.reflect.Field member : members[i]) {
int index = propertyNames.indexOf(member.getName());
if (index >= 0) {
parameterValues[index] = record.getValue(i);
}
}
if (methods[i] != null) {
String name = getPropertyName(methods[i].getName());
int index = propertyNames.indexOf(name);
if (index >= 0) {
parameterValues[index] = record.getValue(i);
}
}
}
}
Object[] converted = Convert.convert(parameterValues, parameterTypes);
return accessible(constructor).newInstance(converted);
} catch (Exception e) {
throw new MappingException("An error ocurred when mapping record to " + type, e);
}
}
@SuppressWarnings("rawtypes")
@Override
public final E map(R record) {
try {
E result = instance != null ? instance : constructor.newInstance();
for (int i = 0; i < fields.length; i++) {
for (java.lang.reflect.Field member : members[i]) {
// [#935] Avoid setting final fields
if ((member.getModifiers() & Modifier.FINAL) == 0) {
map(record, result, member, i);
}
}
for (java.lang.reflect.Method method : methods[i]) {
Class<?> mType = method.getParameterTypes()[0];
Object value = record.getValue(i, mType);
// [#3082] Map nested collection types
if (value instanceof Collection && List.class.isAssignableFrom(mType)) {
Class componentType =
(Class)
((ParameterizedType) method.getGenericParameterTypes()[0])
.getActualTypeArguments()[0];
method.invoke(result, Convert.convert((Collection) value, componentType));
}
// Default reference types (including arrays)
else {
method.invoke(result, record.getValue(i, mType));
}
}
}
for (Entry<String, List<RecordMapper<R, Object>>> entry : nested.entrySet()) {
String prefix = entry.getKey();
for (RecordMapper<R, Object> mapper : entry.getValue()) {
Object value = mapper.map(record);
for (java.lang.reflect.Field member : getMatchingMembers(configuration, type, prefix)) {
// [#935] Avoid setting final fields
if ((member.getModifiers() & Modifier.FINAL) == 0) {
map(value, result, member);
}
}
for (Method method : getMatchingSetters(configuration, type, prefix)) {
method.invoke(result, value);
}
}
}
return result;
} catch (Exception e) {
throw new MappingException("An error ocurred when mapping record to " + type, e);
}
}
private static Object[] convertArray(Array array, Class<? extends Object[]> type)
throws SQLException {
if (array != null) {
return Convert.convert(array.getArray(), type);
}
return null;
}
@Override
public final E map(R record) {
try {
Object[] converted = Convert.convert(record.intoArray(), parameterTypes);
return constructor.newInstance(converted);
} catch (Exception e) {
throw new MappingException("An error ocurred when mapping record to " + type, e);
}
}
private static Object[] convertArray(Object array, Class<? extends Object[]> type)
throws SQLException {
if (array instanceof Object[]) {
return Convert.convert(array, type);
} else if (array instanceof Array) {
return convertArray((Array) array, type);
}
return null;
}
@Override
public final E map(R record) {
int size = record.size();
Class<?> componentType = type.getComponentType();
Object[] result =
(Object[]) (instance != null ? instance : Array.newInstance(componentType, size));
// Just as in Collection.toArray(Object[]), return a new array in case
// sizes don't match
if (size > result.length) {
result = (Object[]) Array.newInstance(componentType, size);
}
for (int i = 0; i < size; i++) {
result[i] = Convert.convert(record.getValue(i), componentType);
}
return (E) result;
}
@SuppressWarnings("unchecked")
private static <T, U> void testConversion(U expected, T from, Class<U> toClass) {
if (from != null) {
assertEquals(from, Convert.convert(from, Object.class));
assertEquals(from, Convert.convert(from, from.getClass()));
}
U conv1 = Convert.convert(from, toClass);
assertEquals(expected, conv1);
if (toClass.isPrimitive()) {
assertTrue(wrapper(toClass).isInstance(conv1));
return;
} else if (expected == null) {
assertNull(conv1);
} else {
assertTrue(toClass.isInstance(conv1));
}
Class<?> toArrayClass = Array.newInstance(toClass, 0).getClass();
Object[] conv2 = Convert.convert(new Object[] {from, from}, new Class[] {toClass, toClass});
U[] conv3 = (U[]) Convert.convert(new Object[] {from, from}, toClass);
U[] conv4 = (U[]) Convert.convertArray(new Object[] {from, from}, toClass);
U[] conv5 = (U[]) Convert.convertArray(new Object[] {from, from}, toArrayClass);
assertEquals(2, conv2.length);
assertEquals(2, conv3.length);
assertEquals(2, conv4.length);
assertEquals(2, conv5.length);
assertEquals(expected, conv2[0]);
assertEquals(expected, conv2[1]);
assertEquals(expected, conv3[0]);
assertEquals(expected, conv3[1]);
assertEquals(expected, conv4[0]);
assertEquals(expected, conv4[1]);
assertEquals(expected, conv5[0]);
assertEquals(expected, conv5[1]);
assertTrue(Object[].class.isInstance(conv2));
assertTrue(toArrayClass.isInstance(conv3));
assertTrue(toArrayClass.isInstance(conv4));
assertTrue(toArrayClass.isInstance(conv5));
}
@SuppressWarnings("rawtypes")
private final void map(Record record, Object result, java.lang.reflect.Field member, int index)
throws IllegalAccessException {
Class<?> mType = member.getType();
if (mType.isPrimitive()) {
if (mType == byte.class) {
map(record.getValue(index, byte.class), result, member);
} else if (mType == short.class) {
map(record.getValue(index, short.class), result, member);
} else if (mType == int.class) {
map(record.getValue(index, int.class), result, member);
} else if (mType == long.class) {
map(record.getValue(index, long.class), result, member);
} else if (mType == float.class) {
map(record.getValue(index, float.class), result, member);
} else if (mType == double.class) {
map(record.getValue(index, double.class), result, member);
} else if (mType == boolean.class) {
map(record.getValue(index, boolean.class), result, member);
} else if (mType == char.class) {
map(record.getValue(index, char.class), result, member);
}
} else {
Object value = record.getValue(index, mType);
// [#3082] Map nested collection types
if (value instanceof Collection && List.class.isAssignableFrom(mType)) {
Class componentType =
(Class) ((ParameterizedType) member.getGenericType()).getActualTypeArguments()[0];
member.set(result, Convert.convert((Collection) value, componentType));
}
// Default reference types (including arrays)
else {
map(value, result, member);
}
}
}
@Override
public final <T, U> U fetchOne(Field<T> field, Converter<? super T, U> converter) {
return Convert.convert(fetchOne(field), converter);
}
@Override
public final <T> T fetchOne(Field<?> field, Class<? extends T> type) {
return Convert.convert(fetchOne(field), type);
}
@Override
public final <T> List<T> getValues(int fieldIndex, Class<? extends T> type) {
return Convert.convert(getValues(fieldIndex), type);
}
@Override
public final <U> List<U> getValues(int fieldIndex, Converter<?, U> converter) {
return Convert.convert(getValues(fieldIndex), converter);
}
@SuppressWarnings("unchecked")
private static <T> T getFromResultSet(ExecuteContext ctx, Class<? extends T> type, int index)
throws SQLException {
ResultSet rs = ctx.resultSet();
if (type == Blob.class) {
return (T) rs.getBlob(index);
} else if (type == Boolean.class) {
return (T) checkWasNull(rs, Boolean.valueOf(rs.getBoolean(index)));
} else if (type == BigInteger.class) {
// The SQLite JDBC driver doesn't support BigDecimals
if (ctx.getDialect() == SQLDialect.SQLITE) {
return Convert.convert(rs.getString(index), (Class<? extends T>) BigInteger.class);
} else {
BigDecimal result = rs.getBigDecimal(index);
return (T) (result == null ? null : result.toBigInteger());
}
} else if (type == BigDecimal.class) {
// The SQLite JDBC driver doesn't support BigDecimals
if (ctx.getDialect() == SQLDialect.SQLITE) {
return Convert.convert(rs.getString(index), (Class<? extends T>) BigDecimal.class);
} else {
return (T) rs.getBigDecimal(index);
}
} else if (type == Byte.class) {
return (T) checkWasNull(rs, Byte.valueOf(rs.getByte(index)));
} else if (type == byte[].class) {
return (T) rs.getBytes(index);
} else if (type == Clob.class) {
return (T) rs.getClob(index);
} else if (type == Date.class) {
return (T) getDate(ctx.getDialect(), rs, index);
} else if (type == Double.class) {
return (T) checkWasNull(rs, Double.valueOf(rs.getDouble(index)));
} else if (type == Float.class) {
return (T) checkWasNull(rs, Float.valueOf(rs.getFloat(index)));
} else if (type == Integer.class) {
return (T) checkWasNull(rs, Integer.valueOf(rs.getInt(index)));
} else if (type == Long.class) {
return (T) checkWasNull(rs, Long.valueOf(rs.getLong(index)));
} else if (type == Short.class) {
return (T) checkWasNull(rs, Short.valueOf(rs.getShort(index)));
} else if (type == String.class) {
return (T) rs.getString(index);
} else if (type == Time.class) {
return (T) getTime(ctx.getDialect(), rs, index);
} else if (type == Timestamp.class) {
return (T) getTimestamp(ctx.getDialect(), rs, index);
} else if (type == YearToMonth.class) {
if (ctx.getDialect() == POSTGRES) {
Object object = rs.getObject(index);
return (T) (object == null ? null : PostgresUtils.toYearToMonth(object));
} else {
String string = rs.getString(index);
return (T) (string == null ? null : YearToMonth.valueOf(string));
}
} else if (type == DayToSecond.class) {
if (ctx.getDialect() == POSTGRES) {
Object object = rs.getObject(index);
return (T) (object == null ? null : PostgresUtils.toDayToSecond(object));
} else {
String string = rs.getString(index);
return (T) (string == null ? null : DayToSecond.valueOf(string));
}
} else if (type == UByte.class) {
String string = rs.getString(index);
return (T) (string == null ? null : UByte.valueOf(string));
} else if (type == UShort.class) {
String string = rs.getString(index);
return (T) (string == null ? null : UShort.valueOf(string));
} else if (type == UInteger.class) {
String string = rs.getString(index);
return (T) (string == null ? null : UInteger.valueOf(string));
} else if (type == ULong.class) {
String string = rs.getString(index);
return (T) (string == null ? null : ULong.valueOf(string));
}
// The type byte[] is handled earlier. byte[][] can be handled here
else if (type.isArray()) {
switch (ctx.getDialect()) {
case POSTGRES:
{
return pgGetArray(ctx, type, index);
}
default:
// Note: due to a HSQLDB bug, it is not recommended to call rs.getObject() here:
// See https://sourceforge.net/tracker/?func=detail&aid=3181365&group_id=23316&atid=378131
return (T) convertArray(rs.getArray(index), (Class<? extends Object[]>) type);
}
} else if (ArrayRecord.class.isAssignableFrom(type)) {
return (T) getArrayRecord(ctx, rs.getArray(index), (Class<? extends ArrayRecord<?>>) type);
} else if (EnumType.class.isAssignableFrom(type)) {
return getEnumType(type, rs.getString(index));
} else if (MasterDataType.class.isAssignableFrom(type)) {
return (T) getMasterDataType(type, rs.getObject(index));
} else if (UDTRecord.class.isAssignableFrom(type)) {
switch (ctx.getDialect()) {
case POSTGRES:
return (T) pgNewUDTRecord(type, rs.getObject(index));
}
return (T) rs.getObject(index, DataTypes.udtRecords());
} else if (Result.class.isAssignableFrom(type)) {
ResultSet nested = (ResultSet) rs.getObject(index);
return (T) getNewFactory(ctx).fetch(nested);
} else {
return (T) rs.getObject(index);
}
}
@Override
public final <T> T getValue(int index, Class<? extends T> type) {
return Convert.convert(getValue(index), type);
}
@Override
public final <T> T fetchOne(String fieldName, Class<? extends T> type) {
return Convert.convert(fetchOne(fieldName), type);
}
@SuppressWarnings("cast")
@Override
public final <T, U> U[] intoArray(Field<T> field, Converter<? super T, U> converter) {
return (U[]) Convert.convertArray(intoArray(field), converter);
}
@Override
public final <T, U> List<U> getValues(Field<T> field, Converter<? super T, U> converter) {
return Convert.convert(getValues(field), converter);
}
@Override
public final <U> U getValue(String fieldName, Converter<?, U> converter) {
return Convert.convert(getValue(fieldName), converter);
}
@Override
public final <T> T getValue(String fieldName, Class<? extends T> type) {
return Convert.convert(getValue(fieldName), type);
}
@Override
public final <U> U getValue(int index, Converter<?, U> converter) {
return Convert.convert(getValue(index), converter);
}
@Override
public final <T> T fetchOne(int fieldIndex, Class<? extends T> type) {
return Convert.convert(fetchOne(fieldIndex), type);
}
@SuppressWarnings("unchecked")
@Override
public final <T> T[] intoArray(Field<?> field, Class<? extends T> type) {
return (T[]) Convert.convertArray(intoArray(field), type);
}
@Override
public final <U> U fetchOne(int fieldIndex, Converter<?, U> converter) {
return Convert.convert(fetchOne(fieldIndex), converter);
}
@SuppressWarnings("cast")
@Override
public final <U> U[] intoArray(String fieldName, Converter<?, U> converter) {
return (U[]) Convert.convertArray(intoArray(fieldName), converter);
}
@Override
public final <U> U fetchOne(String fieldName, Converter<?, U> converter) {
return Convert.convert(fetchOne(fieldName), converter);
}
@Override
public final <T> T getValue(Field<?> field, Class<? extends T> type) {
return Convert.convert(getValue(field), type);
}
