org.babyfish.jimmer.sql.di.AbstractJSqlClientDelegate Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jimmer-sql Show documentation
A revolutionary ORM framework for both java and kotlin
There is a newer version: 0.9.19
package org.babyfish.jimmer.sql.di;

import org.babyfish.jimmer.Input;
import org.babyfish.jimmer.meta.ImmutableProp;
import org.babyfish.jimmer.meta.ImmutableType;
import org.babyfish.jimmer.meta.TypedProp;
import org.babyfish.jimmer.sql.*;
import org.babyfish.jimmer.sql.association.meta.AssociationType;
import org.babyfish.jimmer.sql.ast.mutation.*;
import org.babyfish.jimmer.sql.ast.query.MutableRootQuery;
import org.babyfish.jimmer.sql.ast.query.MutableSubQuery;
import org.babyfish.jimmer.sql.ast.table.AssociationTable;
import org.babyfish.jimmer.sql.ast.table.Table;
import org.babyfish.jimmer.sql.ast.table.TableEx;
import org.babyfish.jimmer.sql.ast.table.spi.TableProxy;
import org.babyfish.jimmer.sql.cache.CacheDisableConfig;
import org.babyfish.jimmer.sql.cache.CacheOperator;
import org.babyfish.jimmer.sql.cache.Caches;
import org.babyfish.jimmer.sql.dialect.Dialect;
import org.babyfish.jimmer.sql.event.TriggerType;
import org.babyfish.jimmer.sql.event.Triggers;
import org.babyfish.jimmer.sql.event.binlog.BinLog;
import org.babyfish.jimmer.sql.fetcher.Fetcher;
import org.babyfish.jimmer.sql.filter.FilterConfig;
import org.babyfish.jimmer.sql.filter.Filters;
import org.babyfish.jimmer.sql.loader.graphql.Loaders;
import org.babyfish.jimmer.sql.meta.*;
import org.babyfish.jimmer.sql.runtime.*;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import java.time.ZoneId;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;

public abstract class AbstractJSqlClientDelegate implements JSqlClientImplementor {

    protected abstract JSqlClientImplementor sqlClient();

    @Override
    public  T unwrap() {
        return sqlClient().unwrap();
    }

    @Override
    public UserIdGenerator getUserIdGenerator(String ref) throws Exception {
        return sqlClient().getUserIdGenerator(ref);
    }

    @Override
    public UserIdGenerator getUserIdGenerator(Class userIdGeneratorType) throws Exception {
        return sqlClient().getUserIdGenerator(userIdGeneratorType);
    }

    @Override
    public LogicalDeletedValueGenerator getLogicalDeletedValueGenerator(String ref) throws Exception {
        return sqlClient().getLogicalDeletedValueGenerator(ref);
    }

    @Override
    public LogicalDeletedValueGenerator getLogicalDeletedValueGenerator(Class logicalDeletedValueGeneratorType) throws Exception {
        return sqlClient().getLogicalDeletedValueGenerator(logicalDeletedValueGeneratorType);
    }

    @Override
    public > MutableRootQuery createQuery(T table) {
        return sqlClient().createQuery(table);
    }

    @Override
    public MutableUpdate createUpdate(TableProxy table) {
        return sqlClient().createUpdate(table);
    }

    @Override
    public MutableDelete createDelete(TableProxy table) {
        return sqlClient().createDelete(table);
    }

    @Override
    public , TE, TT extends Table> MutableRootQuery> createAssociationQuery(AssociationTable table) {
        return sqlClient().createAssociationQuery(table);
    }

    @Override
    public Entities getEntities() {
        return sqlClient().getEntities();
    }

    @Override
    public Triggers getTriggers() {
        return sqlClient().getTriggers();
    }

    @Override
    public Triggers getTriggers(boolean transaction) {
        return sqlClient().getTriggers(transaction);
    }

    @Override
    public Associations getAssociations(TypedProp.Association prop) {
        return sqlClient().getAssociations(prop);
    }

    @Override
    public Associations getAssociations(ImmutableProp immutableProp) {
        return sqlClient().getAssociations(immutableProp);
    }

    @Override
    public Associations getAssociations(AssociationType associationType) {
        return sqlClient().getAssociations(associationType);
    }

    @Override
    public Caches getCaches() {
        return sqlClient().getCaches();
    }

    @Override
    public Filters getFilters() {
        return sqlClient().getFilters();
    }

    @Override
    public BinLog getBinLog() {
        return sqlClient().getBinLog();
    }

    @Override
    public  @Nullable E findById(Class type, Object id) {
        return sqlClient().findById(type, id);
    }

    @Override
    public  @Nullable E findById(Fetcher fetcher, Object id) {
        return sqlClient().findById(fetcher, id);
    }

    @Override
    public  @NotNull List findByIds(Class type, Collection ids) {
        return sqlClient().findByIds(type, ids);
    }

    @Override
    public  @NotNull List findByIds(Fetcher fetcher, Collection ids) {
        return sqlClient().findByIds(fetcher, ids);
    }

    @Override
    public  @NotNull Map findMapByIds(Class type, Collection ids) {
        return sqlClient().findMapByIds(type, ids);
    }

    @Override
    public  @NotNull Map findMapByIds(Fetcher fetcher, Collection ids) {
        return sqlClient().findMapByIds(fetcher, ids);
    }

    @Override
    public  SimpleSaveResult save(E entity, SaveMode mode) {
        return sqlClient().save(entity, mode);
    }

    @Override
    public  SimpleSaveResult save(E entity) {
        return sqlClient().save(entity);
    }

    @Override
    public  SimpleSaveResult insert(E entity) {
        return sqlClient().insert(entity);
    }

    @Override
    public  SimpleSaveResult update(E entity) {
        return sqlClient().update(entity);
    }

    @Override
    public  SimpleSaveResult save(Input input, SaveMode mode) {
        return sqlClient().save(input, mode);
    }

    @Override
    public  SimpleSaveResult save(Input input) {
        return sqlClient().save(input);
    }

    @Override
    public  SimpleSaveResult insert(Input input) {
        return sqlClient().insert(input);
    }

    @Override
    public  SimpleSaveResult update(Input input) {
        return sqlClient().update(input);
    }

    @Override
    public  SimpleSaveResult merge(E entity) {
        return sqlClient().merge(entity);
    }

    @Override
    public  SimpleSaveResult merge(Input input) {
        return sqlClient().merge(input);
    }

    @Override
    public  SimpleSaveResult merge(E entity, SaveMode mode) {
        return sqlClient().merge(entity, mode);
    }

    @Override
    public  SimpleSaveResult merge(Input input, SaveMode mode) {
        return sqlClient().merge(input, mode);
    }

    @Override
    public DeleteResult deleteById(Class type, Object id, DeleteMode mode) {
        return sqlClient().deleteById(type, id, mode);
    }

    @Override
    public DeleteResult deleteById(Class type, Object id) {
        return sqlClient().deleteById(type, id);
    }

    @Override
    public DeleteResult deleteByIds(Class type, Collection ids, DeleteMode mode) {
        return sqlClient().deleteByIds(type, ids, mode);
    }

    @Override
    public DeleteResult deleteByIds(Class type, Collection ids) {
        return sqlClient().deleteByIds(type, ids);
    }

    @Override
    public MutableSubQuery createSubQuery(TableProxy table) {
        return sqlClient().createSubQuery(table);
    }

    @Override
    public , TE, TT extends TableEx> MutableSubQuery createAssociationSubQuery(AssociationTable table) {
        return sqlClient().createAssociationSubQuery(table);
    }

    @Override
    public ConnectionManager getConnectionManager() {
        return sqlClient().getConnectionManager();
    }

    @Override
    public ConnectionManager getSlaveConnectionManager(boolean forUpdate) {
        return sqlClient().getSlaveConnectionManager(forUpdate);
    }

    @Override
    public Dialect getDialect() {
        return sqlClient().getDialect();
    }

    @Override
    public Executor getExecutor() {
        return sqlClient().getExecutor();
    }

    @Override
    public EntityManager getEntityManager() {
        return sqlClient().getEntityManager();
    }

    @Override
    public MetadataStrategy getMetadataStrategy() {
        return sqlClient().getMetadataStrategy();
    }

    @Override
    public List getExecutorContextPrefixes() {
        return sqlClient().getExecutorContextPrefixes();
    }

    @Override
    public SqlFormatter getSqlFormatter() {
        return sqlClient().getSqlFormatter();
    }

    @Override
    public CacheOperator getCacheOperator() {
        return sqlClient().getCacheOperator();
    }

    @Override
    public TriggerType getTriggerType() {
        return sqlClient().getTriggerType();
    }

    @Override
    public  ScalarProvider getScalarProvider(Class scalarType) {
        return sqlClient().getScalarProvider(scalarType);
    }

    @Override
    public  ScalarProvider getScalarProvider(TypedProp prop) {
        return sqlClient().getScalarProvider(prop);
    }

    @Override
    public  ScalarProvider getScalarProvider(ImmutableProp prop) {
        return sqlClient().getScalarProvider(prop);
    }

    @Override
    public ZoneId getZoneId() {
        return sqlClient().getZoneId();
    }

    public IdGenerator getIdGenerator(Class entityType) {
        return sqlClient().getIdGenerator(entityType);
    }

    @Override
    public int getDefaultBatchSize() {
        return sqlClient().getDefaultBatchSize();
    }

    @Override
    public int getDefaultListBatchSize() {
        return sqlClient().getDefaultListBatchSize();
    }

    @Override
    public boolean isInListPaddingEnabled() {
        return sqlClient().isInListPaddingEnabled();
    }

    @Override
    public boolean isExpandedInListPaddingEnabled() {
        return sqlClient().isExpandedInListPaddingEnabled();
    }

    public int getOffsetOptimizingThreshold() {
        return sqlClient().getOffsetOptimizingThreshold();
    }

    @Override
    public LockMode getDefaultLockMode() {
        return sqlClient().getDefaultLockMode();
    }

    @Override
    public int getMaxCommandJoinCount() {
        return sqlClient().getMaxCommandJoinCount();
    }

    @Override
    public boolean isTargetTransferable() {
        return sqlClient().isTargetTransferable();
    }

    @Override
    public @Nullable ExceptionTranslator getExceptionTranslator() {
        return sqlClient().getExceptionTranslator();
    }

    @Override
    public TransientResolver getResolver(ImmutableProp prop) {
        return sqlClient().getResolver(prop);
    }

    @Override
    public StrategyProvider> getUserIdGeneratorProvider() {
        return sqlClient().getUserIdGeneratorProvider();
    }

    @Override
    public StrategyProvider> getTransientResolverProvider() {
        return sqlClient().getTransientResolverProvider();
    }

    @Override
    public boolean isDefaultDissociationActionCheckable() {
        return sqlClient().isDefaultDissociationActionCheckable();
    }

    @Override
    public IdOnlyTargetCheckingLevel getIdOnlyTargetCheckingLevel() {
        return sqlClient().getIdOnlyTargetCheckingLevel();
    }

    @Override
    public DraftPreProcessor getDraftPreProcessor(ImmutableType type) {
        return sqlClient().getDraftPreProcessor(type);
    }

    @Override
    @Nullable
    public DraftInterceptor getDraftInterceptor(ImmutableType type) {
        return sqlClient().getDraftInterceptor(type);
    }

    @Override
    public Reader getReader(Class type) {
        return sqlClient().getReader(type);
    }

    @Override
    public Reader getReader(ImmutableType type) {
        return sqlClient().getReader(type);
    }

    @Override
    public Reader getReader(ImmutableProp prop) {
        return sqlClient().getReader(prop);
    }

    @Override
    public String getMicroServiceName() {
        return sqlClient().getMicroServiceName();
    }

    @Override
    public MicroServiceExchange getMicroServiceExchange() {
        return sqlClient().getMicroServiceExchange();
    }

    @Override
    public JSqlClientImplementor caches(Consumer block) {
        return sqlClient().caches(block);
    }

    @Override
    public JSqlClientImplementor filters(Consumer block) {
        return sqlClient().filters(block);
    }

    @Override
    public JSqlClientImplementor disableSlaveConnectionManager() {
        return sqlClient().disableSlaveConnectionManager();
    }

    @Override
    public JSqlClientImplementor executor(Executor executor) {
        return sqlClient().executor(executor);
    }

    @Override
    public Loaders getLoaders() {
        return sqlClient().getLoaders();
    }

    @Override
    public void initialize() {
        sqlClient().initialize();
    }
}