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
The newest version!
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.Iterator;
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 T 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, Iterable ids) {
        return sqlClient().findByIds(type, ids);
    }

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

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

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

    @Override
    public  SimpleEntitySaveCommand saveCommand(E entity) {
        return sqlClient().saveCommand(entity);
    }

    @Override
    public  SimpleEntitySaveCommand saveCommand(Input input) {
        return sqlClient().saveCommand(input);
    }

    @Override
    public  BatchEntitySaveCommand saveEntitiesCommand(Iterable entities) {
        return sqlClient().saveEntitiesCommand(entities);
    }

    @Override
    public  BatchEntitySaveCommand saveInputsCommand(Iterable> inputs) {
        return sqlClient().saveInputsCommand(inputs);
    }

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

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

    @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 save(@NotNull Input input, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().save(input, associatedMode);
    }

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

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

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

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

    @Override
    public  SimpleSaveResult insert(@NotNull E entity, @NotNull AssociatedSaveMode associatedSaveMode) {
        return sqlClient().insert(entity, associatedSaveMode);
    }

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

    @Override
    public  SimpleSaveResult insert(@NotNull Input input, @NotNull AssociatedSaveMode associatedSaveMode) {
        return sqlClient().insert(input, associatedSaveMode);
    }

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

    @Override
    public  SimpleSaveResult insertIfAbsent(@NotNull E entity, @NotNull AssociatedSaveMode associatedSaveMode) {
        return sqlClient().insertIfAbsent(entity, associatedSaveMode);
    }

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

    @Override
    public  SimpleSaveResult insertIfAbsent(@NotNull Input input, @NotNull AssociatedSaveMode associatedSaveMode) {
        return sqlClient().insertIfAbsent(input, associatedSaveMode);
    }

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

    @Override
    public  SimpleSaveResult update(@NotNull E entity, @NotNull AssociatedSaveMode associatedSaveMode) {
        return sqlClient().update(entity, associatedSaveMode);
    }

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

    @Override
    public  SimpleSaveResult update(@NotNull Input input, @NotNull AssociatedSaveMode associatedSaveMode) {
        return sqlClient().update(input, associatedSaveMode);
    }

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

    @Override
    public  BatchSaveResult saveEntities(@NotNull Iterable entities, @NotNull SaveMode mode, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().saveEntities(entities, mode, associatedMode);
    }

    @Override
    public  BatchSaveResult saveEntities(@NotNull Iterable entities, @NotNull SaveMode mode) {
        return sqlClient().saveEntities(entities, mode);
    }

    @Override
    public  BatchSaveResult saveEntities(@NotNull Iterable entities, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().saveEntities(entities, associatedMode);
    }

    @Override
    public  BatchSaveResult saveEntities(@NotNull Iterable entities) {
        return sqlClient().saveEntities(entities);
    }

    @Override
    public  BatchSaveResult saveInputs(@NotNull Iterable> inputs, @NotNull SaveMode mode, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().saveInputs(inputs, mode, associatedMode);
    }

    @Override
    public  BatchSaveResult saveInputs(@NotNull Iterable> inputs, @NotNull SaveMode mode) {
        return sqlClient().saveInputs(inputs, mode);
    }

    @Override
    public  BatchSaveResult saveInputs(@NotNull Iterable> inputs, AssociatedSaveMode associatedMode) {
        return sqlClient().saveInputs(inputs, associatedMode);
    }

    @Override
    public  BatchSaveResult saveInputs(@NotNull Iterable> inputs) {
        return sqlClient().saveInputs(inputs);
    }

    @Override
    public  BatchSaveResult insertEntities(@NotNull Iterable entities, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().insertEntities(entities, associatedMode);
    }

    @Override
    public  BatchSaveResult insertEntities(@NotNull Iterable entities) {
        return sqlClient().insertEntities(entities);
    }

    @Override
    public  BatchSaveResult insertInputs(@NotNull Iterable> inputs, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().insertInputs(inputs, associatedMode);
    }

    @Override
    public  BatchSaveResult insertInputs(@NotNull Iterable> inputs) {
        return sqlClient().insertInputs(inputs);
    }

    @Override
    public  BatchSaveResult insertEntitiesIfAbsent(@NotNull Iterable entities, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().insertEntitiesIfAbsent(entities, associatedMode);
    }

    @Override
    public  BatchSaveResult insertEntitiesIfAbsent(@NotNull Iterable entities) {
        return sqlClient().insertEntitiesIfAbsent(entities);
    }

    @Override
    public  BatchSaveResult insertInputsIfAbsent(@NotNull Iterable> inputs, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().insertInputsIfAbsent(inputs, associatedMode);
    }

    @Override
    public  BatchSaveResult insertInputsIfAbsent(@NotNull Iterable> inputs) {
        return sqlClient().insertInputsIfAbsent(inputs);
    }

    @Override
    public  BatchSaveResult updateEntities(@NotNull Iterable entities, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().updateEntities(entities, associatedMode);
    }

    @Override
    public  BatchSaveResult updateEntities(@NotNull Iterable entities) {
        return sqlClient().updateEntities(entities);
    }

    @Override
    public  BatchSaveResult updateInputs(@NotNull Iterable> inputs, @NotNull AssociatedSaveMode associatedMode) {
        return sqlClient().updateInputs(inputs, associatedMode);
    }

    @Override
    public  BatchSaveResult updateInputs(@NotNull Iterable> inputs) {
        return sqlClient().updateInputs(inputs);
    }

    @Override
    public  BatchSaveResult mergeEntities(@NotNull Iterable entities) {
        return sqlClient().mergeEntities(entities);
    }

    @Override
    public  BatchSaveResult mergeInputs(@NotNull Iterable> inputs) {
        return sqlClient().mergeInputs(inputs);
    }

    @Override
    public DeleteResult deleteById(@NotNull Class type, @NotNull Object id, @NotNull 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, Iterable ids, DeleteMode mode) {
        return sqlClient().deleteByIds(type, ids, mode);
    }

    @Override
    public DeleteResult deleteByIds(Class type, Iterable 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 boolean isUpsertWithUniqueConstraintSupported(ImmutableType type) {
        return sqlClient().isUpsertWithUniqueConstraintSupported(type);
    }

    @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();
    }
}