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

Go to download
package org.sfm.jdbc.impl;

import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
//IFJAVA8_START
import java.util.stream.Stream;
//IFJAVA8_END
import org.sfm.jdbc.JdbcColumnKey;
import org.sfm.jdbc.JdbcMapper;
import org.sfm.jdbc.JdbcMapperBuilder;
import org.sfm.jdbc.SQLMappingException;
import org.sfm.map.FieldMapperErrorHandler;
import org.sfm.map.MapperBuilderErrorHandler;
import org.sfm.map.MapperBuildingException;
import org.sfm.map.MappingException;
import org.sfm.map.impl.ColumnsMapperKey;
import org.sfm.map.impl.FieldMapper;
import org.sfm.map.impl.MapperCache;
import org.sfm.reflect.ReflectionService;
import org.sfm.reflect.meta.ClassMeta;
import org.sfm.utils.RowHandler;

public final class DynamicJdbcMapper implements JdbcMapper {

	private final ClassMeta classMeta;
	private final Class target;


	private final FieldMapperErrorHandler fieldMapperErrorHandler;

	private final  MapperBuilderErrorHandler mapperBuilderErrorHandler;
	private final Map aliases;
	private Map> customMappings = new HashMap>();
	private MapperCache> mapperCache = new MapperCache>();

	public DynamicJdbcMapper(final Class target, final ReflectionService reflectionService, 
			final FieldMapperErrorHandler fieldMapperErrorHandler, 
			final MapperBuilderErrorHandler mapperBuilderErrorHandler, 
			final Map aliases, 
			final Map> customMappings) {
		this.classMeta = reflectionService.getClassMeta(target);
		this.target = target;
		this.fieldMapperErrorHandler = fieldMapperErrorHandler;
		this.mapperBuilderErrorHandler = mapperBuilderErrorHandler;
		this.aliases = aliases;
		this.customMappings = customMappings;
	}
	

	@Override
	public final T map(final ResultSet source) throws MappingException {
		try {
			final JdbcMapper mapper = buildMapper(source.getMetaData());
			return mapper.map(source);
		} catch(SQLException e) {
			throw new SQLMappingException(e.getMessage(), e);
		}
	}

	@Override
	public final > H forEach(final ResultSet rs, final H handle)
			throws SQLException, MappingException {
		final JdbcMapper mapper = buildMapper(rs.getMetaData());
		return mapper.forEach(rs, handle);
	}
	
	@Override
	public final Iterator iterate(final ResultSet rs)
			throws SQLException, MappingException {
		final JdbcMapper mapper = buildMapper(rs.getMetaData());
		return mapper.iterate(rs);
	}
	
	//IFJAVA8_START
	@Override
	public Stream stream(ResultSet rs) throws SQLException, MappingException {
		final JdbcMapper mapper = buildMapper(rs.getMetaData());
		return mapper.stream(rs);
	}
	//IFJAVA8_END

	private JdbcMapper buildMapper(final ResultSetMetaData metaData) throws MapperBuildingException, SQLException {
		
		final ColumnsMapperKey key = mapperKey(metaData);
		
		JdbcMapper mapper = mapperCache.get(key);
		
		if (mapper == null) {
			final JdbcMapperBuilder builder = new JdbcMapperBuilder(target, classMeta, aliases, customMappings);
			
			builder.fieldMapperErrorHandler(fieldMapperErrorHandler);
			builder.mapperBuilderErrorHandler(mapperBuilderErrorHandler);
			builder.addMapping(metaData);
			
			mapper = builder.mapper();
			mapperCache.add(key, mapper);
		}
		return mapper;
	}
	
	private static ColumnsMapperKey mapperKey(final ResultSetMetaData metaData) throws SQLException {
		final String[] columns = new String[metaData.getColumnCount()];
		
		for(int i = 0; i < columns.length; i++) {
			columns[i] = metaData.getColumnLabel(i + 1);
		}
		
		return new ColumnsMapperKey(columns);
	}



}