org.sfm.jdbc.impl.ResultSetFieldMapperFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of simpleFlatMapper Show documentation
Java library to map flat record - ResultSet, csv - to java object with minimum configuration and low footprint.
There is a newer version: 1.10.3
package org.sfm.jdbc.impl;

import org.sfm.jdbc.JdbcColumnKey;
import org.sfm.jdbc.impl.getter.*;
import org.sfm.map.FieldMapper;
import org.sfm.map.FieldMapperErrorHandler;
import org.sfm.map.GetterFactory;
import org.sfm.map.MapperBuilderErrorHandler;
import org.sfm.map.impl.*;
import org.sfm.map.impl.fieldmapper.*;
import org.sfm.reflect.*;
import org.sfm.reflect.meta.ClassMeta;
import org.sfm.reflect.meta.PropertyMeta;

import java.lang.reflect.Type;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.sql.Types;
import java.util.Date;

public final class ResultSetFieldMapperFactory implements FieldMapperFactory> {

	private final GetterFactory getterFactory;

	public ResultSetFieldMapperFactory(GetterFactory getterFactory) {
		this.getterFactory = getterFactory;
	}


	private  FieldMapper primitiveIndexedFieldMapper(final Class type, final Setter setter, final JdbcColumnKey key, final FieldMapperErrorHandler errorHandler) {
		if (type.equals(Boolean.TYPE)) {
			return new BooleanFieldMapper(
					new BooleanResultSetGetter(key.getIndex()),
					ObjectSetterFactory.toBooleanSetter(setter));
		} else if (type.equals(Integer.TYPE)) {
			return new IntFieldMapper(
					new IntResultSetGetter(key.getIndex()),
					ObjectSetterFactory.toIntSetter(setter));
		} else if (type.equals(Long.TYPE)) {
			return new LongFieldMapper(
					new LongResultSetGetter(key.getIndex()),
					ObjectSetterFactory.toLongSetter(setter));
		} else if (type.equals(Float.TYPE)) {
			return new FloatFieldMapper(
					new FloatResultSetGetter(key.getIndex()),
					ObjectSetterFactory.toFloatSetter(setter));
		} else if (type.equals(Double.TYPE)) {
			return new DoubleFieldMapper(
					new DoubleResultSetGetter(key.getIndex()),
					ObjectSetterFactory.toDoubleSetter(setter));
		} else if (type.equals(Byte.TYPE)) {
			return new ByteFieldMapper(
					new ByteResultSetGetter(key.getIndex()),
					ObjectSetterFactory.toByteSetter(setter));
		} else if (type.equals(Character.TYPE)) {
			return new CharacterFieldMapper(
					new CharacterResultSetGetter(key.getIndex()),
					ObjectSetterFactory.toCharacterSetter(setter));
		} else if (type.equals(Short.TYPE)) {
			return new ShortFieldMapper(
					new ShortResultSetGetter(key.getIndex()),
					ObjectSetterFactory.toShortSetter(setter));
		} else {
			throw new UnsupportedOperationException("Type " + type
					+ " is not primitive");
		}
	}

	@SuppressWarnings("unchecked")
	@Override
	public  FieldMapper newFieldMapper(PropertyMapping> propertyMapping,
                           FieldMapperErrorHandler errorHandler,
                           MapperBuilderErrorHandler mappingErrorHandler) {

		final PropertyMeta propertyMeta = propertyMapping.getPropertyMeta();
		final Type propertyType = propertyMeta.getType();
		final Setter setter = propertyMeta.getSetter();
		final JdbcColumnKey key = propertyMapping.getColumnKey();
		final Class
 type = TypeHelper.toClass(propertyType);

        @SuppressWarnings("unchecked")
		Getter getter = (Getter) propertyMapping.getColumnDefinition().getCustomGetter();

		if (getter == null && type.isPrimitive() && !propertyMapping.getColumnDefinition().hasCustomFactory() ) {
			return this.primitiveIndexedFieldMapper(type, setter, key, errorHandler);
		}

        GetterFactory getterFactory = this.getterFactory;

        if (propertyMapping.getColumnDefinition().hasCustomFactory()) {
            getterFactory = propertyMapping.getColumnDefinition().getCustomGetterFactory();
        }

		if (getter == null) {
			getter = getterFactory.newGetter(propertyType, key, propertyMapping.getColumnDefinition());
		}
		if (getter == null) {
			final ClassMeta classMeta = propertyMeta.getClassMeta();
			for(InstantiatorDefinition id : classMeta.getInstantiatorDefinitions()) {
				if (id.getParameters().length == 1) {
					final Type sourceType = id.getParameters()[0].getGenericType();
					getter = getterFactory.newGetter(sourceType, key, null);
					if (getter != null) {
						Instantiator instantiator =
								classMeta.getReflectionService().getInstantiatorFactory().getOneArgIdentityInstantiator(id);
						getter = new InstantiatorOnGetter(instantiator, getter);
						break;
					}
				}
			}
		}
		if (getter == null) {
			mappingErrorHandler.getterNotFound("Could not find getter for " + key + " type " + propertyType);
			return null;
		} else {
			return new FieldMapperImpl(getter, setter);
		}
	}

	public Class getTargetTypeFromSqlType(int sqlType) {
		switch (sqlType) {
		case Types.LONGNVARCHAR:
		case Types.LONGVARCHAR:
		case Types.CHAR:
		case Types.CLOB:
		case Types.NCHAR:
		case Types.NCLOB:
		case Types.NVARCHAR:
		case Types.VARCHAR:
			return String.class;
			
		case Types.BIGINT:
			return Long.class;
		case Types.INTEGER:
			return Integer.class;
		case Types.SMALLINT:
			return Short.class;
		case Types.TINYINT:
			return Byte.class;
		case Types.NUMERIC:
			return BigDecimal.class;

		case Types.FLOAT:
			return Float.class;
		case Types.DOUBLE:
			return Double.class;

		case Types.BOOLEAN: 
			return Boolean.class;
		case Types.DATE:
		case Types.TIMESTAMP:
				return Date.class;
		}
		return null;
	}

}