org.test4j.module.database.operator.TableOp Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of fluent-dbtest Show documentation
fluent database test
There is a newer version: 1.1.2
package org.test4j.module.database.operator;

import cn.org.atool.fluent.mybatis.metadata.DbType;
import org.test4j.Logger;
import org.test4j.hamcrest.iassert.impl.CollectionAssert;
import org.test4j.hamcrest.iassert.impl.IntegerAssert;
import org.test4j.hamcrest.iassert.impl.ObjectAssert;
import org.test4j.hamcrest.iassert.intf.ICollectionAssert;
import org.test4j.hamcrest.iassert.intf.INumberAssert;
import org.test4j.hamcrest.iassert.intf.IObjectAssert;
import org.test4j.module.database.enviroment.DBEnvironment;
import org.test4j.module.database.enviroment.DBEnvironmentFactory;
import org.test4j.module.database.proxy.Test4JSqlContext;
import org.test4j.module.database.script.DBHelper;
import org.test4j.module.database.script.SqlRunner;
import org.test4j.tools.IKit;
import org.test4j.tools.datagen.IDataMap;

import java.util.List;
import java.util.Map;

import static org.test4j.tools.commons.StringHelper.isBlank;

/**
 * TableOp
 *
 * @author wudarui
 */
@SuppressWarnings({"unchecked", "rawtypes"})
public class TableOp implements ITableOp {
    private final DBEnvironment env;

    private final String table;

    public TableOp(String table) {
        this(DBEnvironmentFactory.getDefaultDBEnvironment(), table);
    }

    public TableOp(DBEnvironment env, String table) {
        this.env = env;
        this.table = table;
        if (isBlank(this.table)) {
            throw new RuntimeException("the table name can't be null.");
        }
    }

    @Override
    public ITableOp clean() {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            // String sql = "delete from " + table;
            String sql = "truncate table " + table;
            SqlRunner.execute(env, sql);
            this.h2truncate();
            return this;
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    /**
     * 修复h2数据库truncate语法错误, 见:
     * https://blog.csdn.net/Soul_wh/article/details/111126632
     * https://github.com/h2database/h2database/issues/2978
     */
    private void h2truncate() {
        if (env.getDbType() != DbType.H2) {
            return;
        }
        String id = env.getTableMetaData(table).getPkColumn();
        if (id != null) {
            SqlRunner.execute(env, String.format("ALTER TABLE %s ALTER COLUMN %s RESTART WITH 1", table, id));
        }
    }

    @Override
    public ITableOp insert(IDataMap... datas) {
        if (datas == null || datas.length == 0) {
            return this;
        }
        Test4JSqlContext.setDbOpStatus(true);
        try {
            for (IDataMap map : datas) {
                InsertOp.insertNoException(env, table, map);
            }
            return this;
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    @Override
    public ICollectionAssert query() {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            List> list = selectData(null);
            return new CollectionAssert(list);
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    @Override
    public ICollectionAssert queryList(Class pojo) {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            String query = "select * from " + table;
            List list = SqlRunner.queryList(env, query, pojo);
            return new CollectionAssert(list);
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    @Override
    public INumberAssert count() {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            String query = "select count(*) from " + table;
            Number number = (Number) SqlRunner.query(env, query, Object.class);
            return new IntegerAssert(number.intValue());
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    @Override
    public ITableOp deleteWhere(String where) {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            String sql = String.format("delete from %s where %s", table, where);
            SqlRunner.execute(env, sql);
            return this;
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    @Override
    public IObjectAssert queryAs(Class pojo) {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            String query = "select * from " + table;
            Object o = SqlRunner.query(env, query, pojo);
            return new ObjectAssert(o);
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    @Override
    public ICollectionAssert queryWhere(String where) {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            List> list = selectData(where);
            return new CollectionAssert(list);
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    @Override
    public ICollectionAssert printAndAssert(String where) {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            List> list = selectData(where);
            Logger.info(IKit.json.toJSON(list, true));
            return new CollectionAssert(list);
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    @Override
    public ICollectionAssert queryWhere(IDataMap dataMap) {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            Map param = dataMap.row(0);
            StringBuilder query = new StringBuilder("select * from ");
            query.append(table).append(" ");
            String where = DBHelper.getWhereCondition(param);
            query.append(where);
            List list = SqlRunner.queryMapList(env, query.toString(), param);
            return new CollectionAssert(list);
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }

    private List> selectData(String where) {
        String _where = isBlank(where) ? "" : " where " + where.trim();
        String query = "select * from " + table + _where;
        return queryData(env, query);
    }

    public static List> queryData(DBEnvironment env, String tableAndWhere) {
        Test4JSqlContext.setDbOpStatus(true);
        try {
            if (tableAndWhere.trim().toLowerCase().startsWith("select")) {
                return SqlRunner.queryMapList(env, tableAndWhere);
            } else {
                String query = "select * from " + tableAndWhere;
                return SqlRunner.queryMapList(env, query);
            }
        } finally {
            Test4JSqlContext.setDbOpStatus(false);
        }
    }
}