• Home
• com.easy-query
• sql-api-proxy
• 2.3.3
• source code
• AbstractEntityQueryable.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.easy.query.api.proxy.entity.select.abstraction.AbstractEntityQueryable Maven / Gradle / Ivy

package com.easy.query.api.proxy.entity.select.abstraction;

import com.easy.query.api.proxy.entity.EntityQueryProxyManager;
import com.easy.query.api.proxy.entity.select.EntityQueryable;
import com.easy.query.api.proxy.entity.select.EntityQueryable2;
import com.easy.query.api.proxy.entity.select.impl.EasyEntityQueryable;
import com.easy.query.api.proxy.entity.select.impl.EasyEntityQueryable2;
import com.easy.query.api.proxy.entity.select.impl.EasySelectFlatQueryable;
import com.easy.query.api.proxy.util.EasyProxyUtil;
import com.easy.query.core.annotation.NotNull;
import com.easy.query.core.api.dynamic.sort.ObjectSort;
import com.easy.query.core.api.pagination.EasyPageResult;
import com.easy.query.core.basic.api.select.ClientQueryable;
import com.easy.query.core.basic.api.select.ClientQueryable2;
import com.easy.query.core.basic.api.select.Query;
import com.easy.query.core.basic.api.select.impl.EasyClientQueryable;
import com.easy.query.core.basic.jdbc.executor.internal.enumerable.JdbcStreamResult;
import com.easy.query.core.basic.jdbc.parameter.ToSQLContext;
import com.easy.query.core.common.OffsetLimitEntry;
import com.easy.query.core.common.ValueHolder;
import com.easy.query.core.context.QueryRuntimeContext;
import com.easy.query.core.enums.sharding.ConnectionModeEnum;
import com.easy.query.core.exception.EasyQueryInvalidOperationException;
import com.easy.query.core.expression.builder.core.ValueFilter;
import com.easy.query.core.expression.lambda.SQLConsumer;
import com.easy.query.core.expression.lambda.SQLExpression1;
import com.easy.query.core.expression.lambda.SQLExpression2;
import com.easy.query.core.expression.lambda.SQLFuncExpression1;
import com.easy.query.core.expression.parser.core.base.tree.TreeCTEConfigurer;
import com.easy.query.core.expression.segment.ColumnSegment;
import com.easy.query.core.expression.sql.builder.EntityQueryExpressionBuilder;
import com.easy.query.core.expression.sql.builder.internal.ContextConfigurer;
import com.easy.query.core.metadata.EntityMetadata;
import com.easy.query.core.metadata.NavigateOrderProp;
import com.easy.query.core.proxy.PropTypeColumn;
import com.easy.query.core.proxy.ProxyEntity;
import com.easy.query.core.proxy.ProxyEntityAvailable;
import com.easy.query.core.proxy.SQLColumn;
import com.easy.query.core.proxy.SQLGroupByExpression;
import com.easy.query.core.proxy.SQLSelectAsExpression;
import com.easy.query.core.proxy.SQLSelectExpression;
import com.easy.query.core.proxy.columns.SQLQueryable;
import com.easy.query.core.proxy.fetcher.EntityFetcher;
import com.easy.query.core.proxy.sql.Select;
import com.easy.query.core.util.EasyCollectionUtil;
import com.easy.query.core.util.EasyNavigateUtil;
import com.easy.query.core.util.EasyObjectUtil;
import com.easy.query.core.util.EasySQLSegmentUtil;

import java.math.BigDecimal;
import java.sql.Statement;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Stream;

/**
 * create time 2023/6/23 22:08
 * 文件说明
 *
 * @author xuejiaming
 */
public abstract class AbstractEntityQueryable, T1> implements EntityQueryable {

    protected final T1Proxy t1Proxy;
    protected final QueryRuntimeContext runtimeContext;
    protected final ClientQueryable clientQueryable;

    public AbstractEntityQueryable(T1Proxy t1Proxy, ClientQueryable clientQueryable) {
        EntityQueryExpressionBuilder sqlEntityExpressionBuilder = clientQueryable.getSQLEntityExpressionBuilder();
        this.runtimeContext = sqlEntityExpressionBuilder.getRuntimeContext();
        this.t1Proxy = t1Proxy.create(sqlEntityExpressionBuilder.getTable(0).getEntityTable(), sqlEntityExpressionBuilder, sqlEntityExpressionBuilder.getRuntimeContext());
        this.clientQueryable = clientQueryable;
    }

    @Override
    public T1Proxy get1Proxy() {
        return t1Proxy;
    }

    @Override
    public QueryRuntimeContext getRuntimeContext() {
        return runtimeContext;
    }

    @Override
    public ClientQueryable getClientQueryable() {
        return clientQueryable;
    }

    @Override
    public EntityQueryable getQueryable() {
        return this;
    }

    @Override
    public Class queryClass() {
        return clientQueryable.queryClass();
    }

    @Override
    public EntityMetadata queryEntityMetadata() {
        return clientQueryable.queryEntityMetadata();
    }

    @Override
    public long count() {
        return clientQueryable.count();
    }

    @Override
    public long countDistinct(SQLFuncExpression1> selectExpression) {
        return getClientQueryable().countDistinct(selector -> {
            SQLColumn sqlColumn = selectExpression.apply(get1Proxy());
            Objects.requireNonNull(sqlColumn, "countDistinct cant get column");
            sqlColumn.accept(selector.getSelector());
        });
    }

    @Override
    public boolean any() {
        return getClientQueryable().any();
    }

    @Override
    public  TR firstOrNull(Class resultClass) {
        return getClientQueryable().firstOrNull(resultClass);
    }

    @Override
    public  TR singleOrNull(Class resultClass) {
        return getClientQueryable().singleOrNull(resultClass);
    }

    @Override
    public T1 findOrNull(Object id) {
        return getClientQueryable().findOrNull(id);
    }


    @NotNull
    @Override
    public  TR firstNotNull(Class resultClass, String msg, String code) {
        return getClientQueryable().firstNotNull(resultClass, msg, code);
    }

    @NotNull
    @Override
    public  TR firstNotNull(Class resultClass, Supplier throwFunc) {
        return getClientQueryable().firstNotNull(resultClass, throwFunc);
    }

    @NotNull
    @Override
    public  TR singleNotNull(Class resultClass, Supplier throwFunc) {
        return getClientQueryable().singleNotNull(resultClass, throwFunc);
    }

    @NotNull
    @Override
    public T1 findNotNull(Object id, Supplier throwFunc) {
        return getClientQueryable().findNotNull(id, throwFunc);
    }

    @Override
    public Map toMap() {
        return getClientQueryable().toMap();
    }

    @Override
    public List> toMaps() {
        return getClientQueryable().toMaps();
    }

    @Override
    public  List toList(Class resultClass) {
        return clientQueryable.toList(resultClass);
    }

    @Override
    public  List toList(Class resultClass, EntityMetadata resultEntityMetadata) {
        return clientQueryable.toList(resultClass, resultEntityMetadata);
    }
    @Override
    public List toTreeList(boolean ignore) {
        return clientQueryable.toTreeList(ignore);
    }

    @Override
    public  JdbcStreamResult toStreamResult(Class resultClass, SQLConsumer configurer) {
        return clientQueryable.toStreamResult(resultClass, configurer);
    }

    @Override
    public void toChunk(int size, Predicate> chunk) {
        clientQueryable.toChunk(size, chunk);
    }

    @Override
    public  TR streamBy(Function, TR> fetcher, SQLConsumer configurer) {
        return clientQueryable.streamBy(fetcher, configurer);
    }

    @Override
    public  String toSQL(Class resultClass, ToSQLContext toSQLContext) {
        return clientQueryable.toSQL(resultClass, toSQLContext);
    }

    @Override
    public  Query selectCount(Class numberClass) {
        return getClientQueryable().selectCount(numberClass);
    }

    @Override
    public  Query selectSum(SQLFuncExpression1> columnSelector) {
        SQLColumn sqlColumn = columnSelector.apply(get1Proxy());
        return getClientQueryable().selectSum(EasyObjectUtil.typeCastNullable(sqlColumn.getPropertyType()), sqlColumn.getValue());
    }

    @Override
    public  Query selectAvg(SQLFuncExpression1> columnSelector) {
        SQLColumn sqlColumn = columnSelector.apply(get1Proxy());
        return getClientQueryable().selectAvg(sqlColumn.getValue());
    }

    @Override
    public  Query selectMax(SQLFuncExpression1> columnSelector) {
        SQLColumn sqlColumn = columnSelector.apply(get1Proxy());
        return getClientQueryable().selectMax(EasyObjectUtil.typeCastNullable(sqlColumn.getPropertyType()), sqlColumn.getValue());
    }

    @Override
    public  Query selectMin(SQLFuncExpression1> columnSelector) {
        SQLColumn sqlColumn = columnSelector.apply(get1Proxy());
        return getClientQueryable().selectMin(EasyObjectUtil.typeCastNullable(sqlColumn.getPropertyType()), sqlColumn.getValue());
    }

    @Override
    public EntityQueryable fetchBy(SQLFuncExpression1 selectExpression) {
        ClientQueryable select = getClientQueryable().select(get1Proxy().getEntityClass(), columnSelector -> {
            SQLSelectExpression sqlSelect = selectExpression.apply(get1Proxy());
            sqlSelect.accept(columnSelector.getAsSelector());
        });
        return new EasyEntityQueryable<>(get1Proxy(), select);
    }

    @Override
    public , TR> EntityQueryable select(SQLFuncExpression1 selectExpression) {
        TRProxy resultProxy = selectExpression.apply(get1Proxy());
        if (resultProxy instanceof EntityFetcher) {
            EntityFetcher resultProxy1 = (EntityFetcher) resultProxy;
            return Select.selectProxy(EasyObjectUtil.typeCastNullable(resultProxy1.fetchProxy()), getClientQueryable());
        }
        return Select.selectProxy(resultProxy, getClientQueryable());
//
//
//        Objects.requireNonNull(resultProxy, "select null result class");
//
//        if (resultProxy instanceof ListProxy) {
//            return Select.selectList((ListProxy) resultProxy,getQueryable().getClientQueryable());
//        }
//
//        SQLSelectAsExpression selectAsExpression = resultProxy.getEntitySQLContext().getSelectAsExpression();
//        if (selectAsExpression == null) {//全属性映射
//            TableAvailable tableOrNull = resultProxy.getTableOrNull();
//            if (tableOrNull == null) {
//                ClientQueryable select = getClientQueryable().select(resultProxy.getEntityClass());
//
//                Select.setDraftPropTypes(select, resultProxy);
//                return new EasyEntityQueryable<>(resultProxy, select);
//            } else {
//                ClientQueryable select = getClientQueryable().select(resultProxy.getEntityClass(), columnAsSelector -> {
//                    columnAsSelector.getAsSelector().columnAll(tableOrNull);
//                });
//                Select.setDraftPropTypes(select, resultProxy);
//                return new EasyEntityQueryable<>(resultProxy, select);
//            }
//        } else {
//            ClientQueryable select = getClientQueryable().select(resultProxy.getEntityClass(), columnAsSelector -> {
//                selectAsExpression.accept(columnAsSelector.getAsSelector());
//            });
//            Select.setDraftPropTypes(select, resultProxy);
//            return new EasyEntityQueryable<>(resultProxy, select);
//        }
    }


    @Override
    public  Query selectColumn(SQLFuncExpression1> selectExpression) {
        PropTypeColumn column = selectExpression.apply(get1Proxy());
        Objects.requireNonNull(column, "select column null result class");

        ClientQueryable select = clientQueryable.select(column.getPropertyType(), o -> {
            PropTypeColumn.selectColumn(o.getAsSelector(), column);
        });
        return EasyObjectUtil.typeCastNullable(select);
    }

//    @Override
//    public , TR> Query> selectMany(SQLFuncExpression1> selectExpression) {
//        SQLQueryable sqlQueryable = selectExpression.apply(get1Proxy());
//        Objects.requireNonNull(sqlQueryable, "select columns null result class");
//        return new EasyColumnsQueryable<>(getClientQueryable(), sqlQueryable.getNavValue());
//    }

    @Override
    public  Query select(Class resultClass) {
        return clientQueryable.select(resultClass);
    }

    @Override
    public  Query select(Class resultClass, SQLFuncExpression1 selectExpression) {
        SQLSelectAsExpression sqlSelectAsExpression = selectExpression.apply(get1Proxy());
        return getClientQueryable().select(resultClass, columnAsSelector -> {
            sqlSelectAsExpression.accept(columnAsSelector.getAsSelector());
        });
    }
//
//    @Override
//    public  Query selectAutoInclude(Class resultClass, boolean replace) {
//        return clientQueryable.selectAutoInclude(resultClass, replace);
//    }

    @Override
    public  Query selectAutoInclude(Class resultClass, SQLFuncExpression1 extraSelectExpression, boolean replace) {
        return clientQueryable.selectAutoInclude(resultClass, columnAsSelector -> {
            if (extraSelectExpression != null) {
                SQLSelectAsExpression sqlSelectAsExpression = extraSelectExpression.apply(get1Proxy());
                if (sqlSelectAsExpression != null) {
                    sqlSelectAsExpression.accept(columnAsSelector.getAsSelector());
                }
            }
        }, replace);
    }
    //    private void selectAutoInclude0(EntityMetadataManager entityMetadataManager, ClientQueryable clientQueryable, EntityMetadata entityMetadata, EntityMetadata resultEntityMetadata) {
//        Collection resultNavigateMetadatas = resultEntityMetadata.getNavigateMetadatas();
//        if(EasyCollectionUtil.isEmpty(resultNavigateMetadatas)){
//            return;
//        }
//        for (NavigateMetadata resultNavigateMetadata : resultNavigateMetadatas) {
//            NavigateMetadata entityNavigateMetadata = entityMetadata.getNavigateOrNull(resultNavigateMetadata.getPropertyName());
//            if (entityNavigateMetadata == null) {
//                continue;
//            }
//
//            clientQueryable
//                    .include(t -> {
//                        ClientQueryable