All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • com.easy.query.api4j.client.EasyQuery Maven / Gradle / Ivy

    There is a newer version: 2.3.3
    Show newest version
    package com.easy.query.api4j.client;

import com.easy.query.api4j.delete.EntityDeletable;
import com.easy.query.api4j.delete.ExpressionDeletable;
import com.easy.query.api4j.insert.EntityInsertable;
import com.easy.query.api4j.select.Queryable;
import com.easy.query.api4j.update.EntityUpdatable;
import com.easy.query.api4j.update.ExpressionUpdatable;
import com.easy.query.core.api.client.EasyQueryClient;
import com.easy.query.core.basic.api.insert.map.MapClientInsertable;
import com.easy.query.core.basic.api.update.map.MapClientUpdatable;
import com.easy.query.core.basic.extension.track.EntityState;
import com.easy.query.core.basic.jdbc.parameter.SQLParameter;
import com.easy.query.core.basic.jdbc.tx.Transaction;
import com.easy.query.core.context.QueryRuntimeContext;

import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;

/**
 * create time 2023/2/5 21:27
 * lambda表达式可查询客户端
 *
 * @author xuejiaming
 */
public interface EasyQuery {
    /**
     * 获取属性模式的查询客户端
     * @return 属性模式查询客户端
     */
    EasyQueryClient getEasyQueryClient();

    /**
     * 获取当前easy-query的上下文
     * @return easy-query的上下文
     */
    QueryRuntimeContext getRuntimeContext();

    /**
     * 按sql查询结果映射到 {@param clazz} 对象上
     * @param sql 查询的sql
     * @param clazz 返回的结果字节
     * @return 查询结果集
     * @param  返回结果类型
     */
    default  List sqlQuery(String sql, Class clazz) {
        return getEasyQueryClient().sqlQuery(sql, clazz);
    }

    /**
     * 按sql查询结果映射到 {@param clazz} 对象上
     * @param sql 查询的sql
     * @param clazz 返回的结果字节
     * @param parameters sql参数
     * @return 查询结果集
     * @param  返回结果类型
     */
    default  List sqlQuery(String sql, Class clazz, List parameters) {
        return getEasyQueryClient().sqlQuery(sql, clazz, parameters);
    }

    /**
     * 按sql查询结果映射到 {@param clazz} 对象上
     * @param sql 查询的sql
     * @param clazz 返回的结果字节
     * @param parameters sql参数 easyQuery参数
     * @return 查询结果集
     * @param  返回结果类型
     */
    default  List sqlEasyQuery(String sql, Class clazz, List parameters) {
        return getEasyQueryClient().sqlEasyQuery(sql, clazz, parameters);
    }

    /**
     * 按sql查询结果映射到 Map 对象上
     * @param sql 查询的sql
     * @return 查询结果集
     */
    default List> sqlQueryMap(String sql) {
        return getEasyQueryClient().sqlQueryMap(sql);
    }

    default List> sqlQueryMap(String sql, List parameters) {
        return getEasyQueryClient().sqlQueryMap(sql, parameters);
    }

    default long sqlExecute(String sql) {
        return getEasyQueryClient().sqlExecute(sql);
    }

    default long sqlExecute(String sql, List parameters) {
        return getEasyQueryClient().sqlExecute(sql, parameters);
    }

    /**
     * 创建一个可查询表达式
     * @param clazz 被查询的对象字节
     * @return 可查询的表达式接口
     * @param  被查询的对象类型
     */
     Queryable queryable(Class clazz);

    /**
     * 通过sql语句匿名表模式创建一个可查询表达式
     * select * from ( {@param sql} ) t
     * @param sql sql语句
     * @param clazz 被查询的对象字节
     * @return 可查询的表达式接口
     * @param  被查询的对象类型
     */
    default  Queryable queryable(String sql, Class clazz) {
        return queryable(sql, clazz, Collections.emptyList());
    }

     Queryable queryable(String sql, Class clazz, Collection sqlParams);

    default Transaction beginTransaction() {
        return beginTransaction(null);
    }

    /**
     * 数据库隔离级别:
     * Connection.TRANSACTION_READ_UNCOMMITTED,
     * Connection.TRANSACTION_READ_COMMITTED,
     * Connection.TRANSACTION_REPEATABLE_READ,
     * Connection.TRANSACTION_SERIALIZABLE
     *
     * @param isolationLevel null表示不使用任何指定隔离级别,使用默认的
     * @return
     */
    Transaction beginTransaction(Integer isolationLevel);

     EntityInsertable insertable(T entity);

     EntityInsertable insertable(Collection entities);

     ExpressionUpdatable updatable(Class entityClass);

     EntityUpdatable updatable(T entity);

     EntityUpdatable updatable(Collection entities);


     EntityDeletable deletable(T entity);

     EntityDeletable deletable(Collection entities);

     ExpressionDeletable deletable(Class entityClass);

    /**
     * 添加到当前环境的追踪里面
     * 如果当前线程未开启追踪那么添加直接忽略无效
     * 相同对象多次追踪结果还是true
     *
     * @param entity
     * @return true:添加成功,false:已经存在相同对象 或者未开启追踪
     */
    boolean addTracking(Object entity);

    boolean removeTracking(Object entity);

    EntityState getTrackEntityStateNotNull(Object entity);

    default MapClientInsertable> mapInsertable(Map map) {
        return getEasyQueryClient().mapInsertable(map);
    }

    default MapClientInsertable> mapInsertable(Collection> maps) {
        return getEasyQueryClient().mapInsertable(maps);
    }
    default MapClientUpdatable> mapUpdatable(Map map) {
        return getEasyQueryClient().mapUpdatable(map);
    }

    default MapClientUpdatable> mapUpdatable(Collection> maps) {
        return getEasyQueryClient().mapUpdatable(maps);
    }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy