co.jirm.mapper.jdbc.JdbcSqlObjectQueryExecutor.java Source code

Introduction

Here is the source code for co.jirm.mapper.jdbc.JdbcSqlObjectQueryExecutor.java

Source

/**
 * Copyright (C) 2012 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package co.jirm.mapper.jdbc;

import static java.util.Arrays.asList;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import co.jirm.core.execute.SqlMultiValueRowMapper;
import co.jirm.core.execute.SqlQueryExecutor;
import co.jirm.core.execute.SqlSingleValueRowMapper;
import co.jirm.core.util.ObjectMapUtils;
import co.jirm.mapper.SqlObjectConfig;
import co.jirm.mapper.definition.SqlObjectDefinition;

import com.google.common.base.Optional;

public abstract class JdbcSqlObjectQueryExecutor implements SqlQueryExecutor {

    private final SqlObjectConfig objectConfig;
    private final JdbcResultSetMapperHelper helper = new JdbcResultSetMapperHelper();

    protected JdbcSqlObjectQueryExecutor(SqlObjectConfig objectConfig) {
        super();
        this.objectConfig = objectConfig;
    }

    protected <T> JdbcResultSetRowMapper<T> createJdbcMapper(final SqlMultiValueRowMapper<T> rowMapper) {
        final SqlObjectDefinition<T> objectDefinition = objectConfig
                .resolveObjectDefinition(rowMapper.getObjectType());
        return new JdbcResultSetRowMapper<T>() {

            @Override
            public T mapRow(ResultSet rs, int rowNum) throws SQLException {
                Map<String, Object> m = helper.mapRow(objectDefinition, rs, rowNum);
                return rowMapper.mapRow(m, rowNum);
            }
        };
    }

    @Override
    public final <T> T queryForObject(String sql, SqlSingleValueRowMapper rowMapper, Class<T> type,
            Object[] objects) {
        logSql(sql, objects);
        nullify(objects);
        return doQueryForObject(sql, rowMapper, type, objects);
    }

    protected abstract <T> T doQueryForObject(String sql, SqlSingleValueRowMapper rowMapper, Class<T> type,
            Object[] objects);

    @Override
    public final <T> Optional<T> queryForOptional(String sql, SqlSingleValueRowMapper rowMapper, Class<T> type,
            Object[] objects) {
        logSql(sql, objects);
        nullify(objects);
        return doQueryForOptional(sql, rowMapper, type, objects);
    }

    protected abstract <T> Optional<T> doQueryForOptional(String sql, SqlSingleValueRowMapper rowMapper,
            Class<T> type, Object[] objects);

    @Override
    public final <T> List<T> queryForList(String sql, SqlSingleValueRowMapper rowMapper, Class<T> type,
            Object[] objects) {
        logSql(sql, objects);
        nullify(objects);
        return doQueryForList(sql, rowMapper, type, objects);
    }

    protected abstract <T> List<T> doQueryForList(String sql, SqlSingleValueRowMapper rowMapper, Class<T> type,
            Object[] objects);

    @Override
    public final long queryForLong(String sql, Object[] objects) {
        logSql(sql, objects);
        nullify(objects);
        return doQueryForLong(sql, objects);
    }

    protected abstract long doQueryForLong(String sql, Object[] objects);

    @Override
    public final int queryForInt(String sql, Object[] objects) {
        logSql(sql, objects);
        nullify(objects);
        return doQueryForInt(sql, objects);
    }

    protected abstract int doQueryForInt(String sql, Object[] objects);

    @Override
    public final <T> T queryForObject(String sql, SqlMultiValueRowMapper<T> rowMapper, Object[] objects) {
        return queryForObject(sql, createJdbcMapper(rowMapper), objects);
    }

    protected void logSql(String sql, Object[] objects) {
        if (log.isDebugEnabled()) {
            log.debug("sql: {}; values: {}", sql,
                    ObjectMapUtils.toStringList(new StringBuilder(), asList(objects), 100));
        }
    }

    @Override
    public final <T> Optional<T> queryForOptional(String sql, SqlMultiValueRowMapper<T> rowMapper,
            Object[] objects) {
        return queryForOptional(sql, createJdbcMapper(rowMapper), objects);
    }

    @Override
    public final <T> List<T> queryForList(String sql, SqlMultiValueRowMapper<T> rowMapper, Object[] objects) {
        return queryForList(sql, createJdbcMapper(rowMapper), objects);
    }

    public final <T> T queryForObject(String sql, JdbcResultSetRowMapper<T> rowMapper, Object[] objects) {
        logSql(sql, objects);
        nullify(objects);
        return doQueryForObject(sql, rowMapper, objects);
    }

    public final <T> Optional<T> queryForOptional(String sql, JdbcResultSetRowMapper<T> rowMapper,
            Object[] objects) {
        logSql(sql, objects);
        nullify(objects);
        return doQueryForOptional(sql, rowMapper, objects);
    }

    public final <T> List<T> queryForList(String sql, JdbcResultSetRowMapper<T> rowMapper, Object[] objects) {
        logSql(sql, objects);
        nullify(objects);
        return doQueryForList(sql, rowMapper, objects);
    }

    protected void nullify(Object[] objects) {
        for (int i = 0; i < objects.length; i++) {
            Object o = objects[i];
            if (o instanceof Optional) {
                Optional<?> opt = (Optional<?>) o;
                objects[i] = opt.orNull();
            }
        }
    }

    protected abstract <T> T doQueryForObject(String sql, JdbcResultSetRowMapper<T> rowMapper, Object[] objects);

    protected abstract <T> Optional<T> doQueryForOptional(String sql, JdbcResultSetRowMapper<T> rowMapper,
            Object[] objects);

    protected abstract <T> List<T> doQueryForList(String sql, JdbcResultSetRowMapper<T> rowMapper,
            Object[] objects);

    private static final Logger log = LoggerFactory.getLogger(JdbcSqlObjectQueryExecutor.class);

}