com.easy.query.api.proxy.entity.insert.AbstractEntityInsertable Maven / Gradle / Ivy

Go to download
package com.easy.query.api.proxy.entity.insert;

import com.easy.query.api.proxy.entity.insert.extension.ProxyColumnConfigurer;
import com.easy.query.api.proxy.entity.insert.extension.ProxyColumnConfigurerImpl;
import com.easy.query.core.basic.api.insert.ClientInsertable;
import com.easy.query.core.basic.jdbc.parameter.ToSQLContext;
import com.easy.query.core.enums.SQLExecuteStrategyEnum;
import com.easy.query.core.expression.builder.impl.FetchSelector;
import com.easy.query.core.expression.lambda.SQLExpression1;
import com.easy.query.core.expression.lambda.SQLFuncExpression1;
import com.easy.query.core.expression.sql.builder.EntityInsertExpressionBuilder;
import com.easy.query.core.expression.sql.builder.internal.ContextConfigurer;
import com.easy.query.core.expression.sql.builder.internal.EasyBehavior;
import com.easy.query.core.proxy.ProxyEntity;
import com.easy.query.core.proxy.SQLSelectExpression;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Function;

/**
 * create time 2023/12/7 13:28
 * 文件说明
 *
 * @author xuejiaming
 */
public class AbstractEntityInsertable, T> implements EntityInsertable {
    private final TProxy tProxy;
    private final ClientInsertable clientInsertable;

    public AbstractEntityInsertable(TProxy tProxy, ClientInsertable clientInsertable) {
        this.clientInsertable = clientInsertable;
        this.tProxy = tProxy.create(clientInsertable.getEntityInsertExpressionBuilder().getTable(0).getEntityTable(),clientInsertable.getEntityInsertExpressionBuilder(), getEntityInsertExpressionBuilder().getRuntimeContext());

    }

    @Override
    public EntityInsertExpressionBuilder getEntityInsertExpressionBuilder() {
        return clientInsertable.getEntityInsertExpressionBuilder();
    }

    @Override
    public long executeRows(boolean fillAutoIncrement) {
        return clientInsertable.executeRows(fillAutoIncrement);
    }

    @Override
    public String toSQL(T entity) {
        return clientInsertable.toSQL(entity);
    }

    @Override
    public String toSQL(T entity, ToSQLContext toSQLContext) {
        return clientInsertable.toSQL(entity, toSQLContext);
    }

    @Override
    public EntityInsertable noInterceptor() {
        clientInsertable.noInterceptor();
        return this;
    }

    @Override
    public EntityInsertable useInterceptor(String name) {
        clientInsertable.useInterceptor(name);
        return this;
    }

    @Override
    public EntityInsertable noInterceptor(String name) {
        clientInsertable.noInterceptor(name);
        return this;
    }

    @Override
    public EntityInsertable useInterceptor() {
        clientInsertable.useInterceptor();
        return this;
    }

    @Override
    public EntityInsertable batch(boolean use) {
        clientInsertable.batch(use);
        return this;
    }

    @Override
    public EntityInsertable setSQLStrategy(boolean condition, SQLExecuteStrategyEnum sqlStrategy) {
        clientInsertable.setSQLStrategy(condition,sqlStrategy);
        return this;
    }

    @Override
    public EntityInsertable onDuplicateKeyIgnore() {
        clientInsertable.onDuplicateKeyIgnore();
        return this;
    }

    @Override
    public EntityInsertable asTable(Function tableNameAs) {
        clientInsertable.asTable(tableNameAs);
        return this;
    }

    @Override
    public EntityInsertable asSchema(Function schemaAs) {
        clientInsertable.asSchema(schemaAs);
        return this;
    }

    @Override
    public EntityInsertable asAlias(String alias) {
        clientInsertable.asAlias(alias);
        return this;
    }

    @Override
    public EntityInsertable asTableLink(Function linkAs) {
        clientInsertable.asTableLink(linkAs);
        return this;
    }
    @Override
    public EntityInsertable configure(SQLExpression1 configurer) {
        clientInsertable.configure(configurer);
        return this;
    }

    @Override
    public EntityInsertable insert(T entity) {
        clientInsertable.insert(entity);
        return this;
    }

    @Override
    public EntityInsertable insert(Collection entities) {
        clientInsertable.insert(entities);
        return this;
    }

    @Override
    public EntityInsertable columnConfigure(SQLExpression1> columnConfigureExpression) {
        clientInsertable.columnConfigure(c->{
            columnConfigureExpression.apply(new ProxyColumnConfigurerImpl<>(c.getConfigurer()));
        });
        return this;
    }

    @Override
    public EntityInsertable onConflictThen(SQLFuncExpression1 updateSetSelector, SQLFuncExpression1 constraintPropertySelector) {
        Collection constraintProperties = parseConstraintProperties(constraintPropertySelector);
        clientInsertable.onConflictThen(o->{
            if(updateSetSelector!=null){
                SQLSelectExpression sqlSelectExpression = updateSetSelector.apply(tProxy);
                if(sqlSelectExpression!=null){
                    sqlSelectExpression.accept(o.getOnlySelector());
                }
            }
        },constraintProperties);
        return this;
    }

    @Override
    public EntityInsertable onConflictDoUpdate() {
        clientInsertable.onConflictDoUpdate();
        return this;
    }

    @Override
    public EntityInsertable onConflictDoUpdate(SQLFuncExpression1 constraintPropertyExpression) {
        Collection constraintProperties = parseConstraintProperties(constraintPropertyExpression);
        clientInsertable.onConflictDoUpdate(constraintProperties);
        return this;
    }

    @Override
    public EntityInsertable onConflictDoUpdate(SQLFuncExpression1 constraintPropertyExpression, SQLFuncExpression1 updatePropertyExpression) {
        Collection constraintProperties = parseConstraintProperties(constraintPropertyExpression);
        clientInsertable.onConflictDoUpdate(constraintProperties,s->{
            SQLSelectExpression sqlSelectExpression = updatePropertyExpression.apply(tProxy);
            sqlSelectExpression.accept(s.getOnlySelector());
        });
        return this;
    }
    private Collection parseConstraintProperties(SQLFuncExpression1 constraintPropertySelector){
        if(constraintPropertySelector!=null){
            SQLSelectExpression columnExpression = constraintPropertySelector.apply(tProxy);
            if(columnExpression!=null){
                ArrayList properties = new ArrayList<>();
                FetchSelector fetchSelector = new FetchSelector(properties);
                columnExpression.accept(fetchSelector);
                return properties;
            }
        }
        return null;
    }

    @Override
    public EntityInsertable onDuplicateKeyUpdate() {
        clientInsertable.onDuplicateKeyUpdate();
        return this;
    }

    @Override
    public EntityInsertable onDuplicateKeyUpdate(SQLFuncExpression1 updatePropertyExpression) {
        clientInsertable.onDuplicateKeyUpdate(s->{
            SQLSelectExpression sqlSelectExpression = updatePropertyExpression.apply(tProxy);
            sqlSelectExpression.accept(s.getOnlySelector());
        });
        return this;
    }
}