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

    • com.torodb.testing.docker.sql.ConnectionOwnerDslContext Maven / Gradle / Ivy

    /*
 * Copyright 2017 8Kdata Technology
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.torodb.testing.docker.sql;

import org.jooq.AlterSequenceRestartStep;
import org.jooq.AlterTableStep;
import org.jooq.Attachable;
import org.jooq.Batch;
import org.jooq.BatchBindStep;
import org.jooq.BindContext;
import org.jooq.CommonTableExpression;
import org.jooq.Condition;
import org.jooq.Configuration;
import org.jooq.ConnectionCallable;
import org.jooq.ConnectionRunnable;
import org.jooq.CreateIndexStep;
import org.jooq.CreateSequenceFinalStep;
import org.jooq.CreateTableAsStep;
import org.jooq.CreateViewAsStep;
import org.jooq.Cursor;
import org.jooq.DDLFlag;
import org.jooq.DSLContext;
import org.jooq.DataType;
import org.jooq.DeleteQuery;
import org.jooq.DeleteWhereStep;
import org.jooq.DropIndexOnStep;
import org.jooq.DropSequenceFinalStep;
import org.jooq.DropTableStep;
import org.jooq.DropViewFinalStep;
import org.jooq.Field;
import org.jooq.InsertQuery;
import org.jooq.InsertSetStep;
import org.jooq.InsertValuesStep1;
import org.jooq.InsertValuesStep10;
import org.jooq.InsertValuesStep11;
import org.jooq.InsertValuesStep12;
import org.jooq.InsertValuesStep13;
import org.jooq.InsertValuesStep14;
import org.jooq.InsertValuesStep15;
import org.jooq.InsertValuesStep16;
import org.jooq.InsertValuesStep17;
import org.jooq.InsertValuesStep18;
import org.jooq.InsertValuesStep19;
import org.jooq.InsertValuesStep2;
import org.jooq.InsertValuesStep20;
import org.jooq.InsertValuesStep21;
import org.jooq.InsertValuesStep22;
import org.jooq.InsertValuesStep3;
import org.jooq.InsertValuesStep4;
import org.jooq.InsertValuesStep5;
import org.jooq.InsertValuesStep6;
import org.jooq.InsertValuesStep7;
import org.jooq.InsertValuesStep8;
import org.jooq.InsertValuesStep9;
import org.jooq.InsertValuesStepN;
import org.jooq.LoaderOptionsStep;
import org.jooq.MergeKeyStep1;
import org.jooq.MergeKeyStep10;
import org.jooq.MergeKeyStep11;
import org.jooq.MergeKeyStep12;
import org.jooq.MergeKeyStep13;
import org.jooq.MergeKeyStep14;
import org.jooq.MergeKeyStep15;
import org.jooq.MergeKeyStep16;
import org.jooq.MergeKeyStep17;
import org.jooq.MergeKeyStep18;
import org.jooq.MergeKeyStep19;
import org.jooq.MergeKeyStep2;
import org.jooq.MergeKeyStep20;
import org.jooq.MergeKeyStep21;
import org.jooq.MergeKeyStep22;
import org.jooq.MergeKeyStep3;
import org.jooq.MergeKeyStep4;
import org.jooq.MergeKeyStep5;
import org.jooq.MergeKeyStep6;
import org.jooq.MergeKeyStep7;
import org.jooq.MergeKeyStep8;
import org.jooq.MergeKeyStep9;
import org.jooq.MergeKeyStepN;
import org.jooq.MergeUsingStep;
import org.jooq.Meta;
import org.jooq.Name;
import org.jooq.Param;
import org.jooq.Queries;
import org.jooq.Query;
import org.jooq.QueryPart;
import org.jooq.Record;
import org.jooq.Record1;
import org.jooq.Record10;
import org.jooq.Record11;
import org.jooq.Record12;
import org.jooq.Record13;
import org.jooq.Record14;
import org.jooq.Record15;
import org.jooq.Record16;
import org.jooq.Record17;
import org.jooq.Record18;
import org.jooq.Record19;
import org.jooq.Record2;
import org.jooq.Record20;
import org.jooq.Record21;
import org.jooq.Record22;
import org.jooq.Record3;
import org.jooq.Record4;
import org.jooq.Record5;
import org.jooq.Record6;
import org.jooq.Record7;
import org.jooq.Record8;
import org.jooq.Record9;
import org.jooq.RenderContext;
import org.jooq.Result;
import org.jooq.ResultQuery;
import org.jooq.Results;
import org.jooq.SQL;
import org.jooq.SQLDialect;
import org.jooq.Schema;
import org.jooq.Select;
import org.jooq.SelectField;
import org.jooq.SelectQuery;
import org.jooq.SelectSelectStep;
import org.jooq.SelectWhereStep;
import org.jooq.Sequence;
import org.jooq.Table;
import org.jooq.TableField;
import org.jooq.TableLike;
import org.jooq.TableRecord;
import org.jooq.TransactionalCallable;
import org.jooq.TransactionalRunnable;
import org.jooq.TruncateIdentityStep;
import org.jooq.UDT;
import org.jooq.UDTRecord;
import org.jooq.UpdatableRecord;
import org.jooq.UpdateQuery;
import org.jooq.UpdateSetFirstStep;
import org.jooq.WithAsStep;
import org.jooq.WithAsStep1;
import org.jooq.WithAsStep10;
import org.jooq.WithAsStep11;
import org.jooq.WithAsStep12;
import org.jooq.WithAsStep13;
import org.jooq.WithAsStep14;
import org.jooq.WithAsStep15;
import org.jooq.WithAsStep16;
import org.jooq.WithAsStep17;
import org.jooq.WithAsStep18;
import org.jooq.WithAsStep19;
import org.jooq.WithAsStep2;
import org.jooq.WithAsStep20;
import org.jooq.WithAsStep21;
import org.jooq.WithAsStep22;
import org.jooq.WithAsStep3;
import org.jooq.WithAsStep4;
import org.jooq.WithAsStep5;
import org.jooq.WithAsStep6;
import org.jooq.WithAsStep7;
import org.jooq.WithAsStep8;
import org.jooq.WithAsStep9;
import org.jooq.WithStep;
import org.jooq.conf.Settings;
import org.jooq.exception.DataAccessException;
import org.jooq.exception.InvalidResultException;
import org.jooq.exception.TooManyRowsException;
import org.jooq.impl.DSL;
import org.jooq.impl.DefaultConnectionProvider;
import org.jooq.lambda.UncheckedException;
import org.jooq.tools.jdbc.JDBCUtils;
import org.jooq.tools.jdbc.MockCallable;
import org.jooq.tools.jdbc.MockDataProvider;
import org.jooq.tools.jdbc.MockRunnable;

import java.math.BigInteger;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;
import java.util.stream.Stream;

import javax.sql.DataSource;

/**
 * A {@link DSLContext} whose lifecycle is associated with a single connection.
 *
 * When this object is closed, it calls {@link Connection#close() }.
 */
@SuppressWarnings({"checkstyle:LineLength", "checkstyle:MethodTypeParameterName", "checkstyle:OverloadMethodsDeclarationOrder"})
public class ConnectionOwnerDslContext implements DSLContext {

  private final Connection connection;
  private final DSLContext delegate;

  public ConnectionOwnerDslContext(Connection connection, SQLDialect dialect) {
    this.connection = connection;
    this.delegate = DSL.using(new DefaultConnectionProvider(connection), dialect);
  }

  public ConnectionOwnerDslContext(DataSource datasource, SQLDialect dialect) {
    try {
      this.connection = datasource.getConnection();
      this.delegate = DSL.using(new DefaultConnectionProvider(connection), dialect);
    } catch (SQLException ex) {
      throw new UncheckedException(ex);
    }
  }

  @Override
  public void close() throws DataAccessException {
    delegate.close();
    JDBCUtils.safeClose(connection);
  }

  @Override
  public Schema map(Schema schema) {
    return delegate.map(schema);
  }

  @Override
  public  Table map(Table table) {
    return delegate.map(table);
  }

  @Override
  public Meta meta() {
    return delegate.meta();
  }

  @Override
  public  T transactionResult(TransactionalCallable transactional) {
    return delegate.transactionResult(transactional);
  }

  @Override
  public void transaction(TransactionalRunnable transactional) {
    delegate.transaction(transactional);
  }

  @Override
  public  CompletionStage transactionResultAsync(TransactionalCallable transactional) {
    return delegate.transactionResultAsync(transactional);
  }

  @Override
  public CompletionStage transactionAsync(TransactionalRunnable transactional) {
    return delegate.transactionAsync(transactional);
  }

  @Override
  public  CompletionStage transactionResultAsync(Executor executor,
      TransactionalCallable transactional) {
    return delegate.transactionResultAsync(executor, transactional);
  }

  @Override
  public CompletionStage transactionAsync(Executor executor,
      TransactionalRunnable transactional) {
    return delegate.transactionAsync(executor, transactional);
  }

  @Override
  public  T connectionResult(ConnectionCallable callable) {
    return delegate.connectionResult(callable);
  }

  @Override
  public void connection(ConnectionRunnable runnable) {
    delegate.connection(runnable);
  }

  @Override
  public  T mockResult(MockDataProvider provider, MockCallable mockable) {
    return delegate.mockResult(provider, mockable);
  }

  @Override
  public void mock(MockDataProvider provider, MockRunnable mockable) {
    delegate.mock(provider, mockable);
  }

  @Override
  public RenderContext renderContext() {
    return delegate.renderContext();
  }

  @Override
  public String render(QueryPart part) {
    return delegate.render(part);
  }

  @Override
  public String renderNamedParams(QueryPart part) {
    return delegate.renderNamedParams(part);
  }

  @Override
  public String renderNamedOrInlinedParams(QueryPart part) {
    return delegate.renderNamedOrInlinedParams(part);
  }

  @Override
  public String renderInlined(QueryPart part) {
    return delegate.renderInlined(part);
  }

  @Override
  public List extractBindValues(QueryPart part) {
    return delegate.extractBindValues(part);
  }

  @Override
  public Map> extractParams(QueryPart part) {
    return delegate.extractParams(part);
  }

  @Override
  public Param extractParam(QueryPart part, String name) {
    return delegate.extractParam(part, name);
  }

  @Override
  public BindContext bindContext(PreparedStatement stmt) {
    return delegate.bindContext(stmt);
  }

  @Override
  public int bind(QueryPart part, PreparedStatement stmt) {
    return delegate.bind(part, stmt);
  }

  @Override
  public void attach(Attachable... attachables) {
    delegate.attach(attachables);
  }

  @Override
  public void attach(
      Collection attachables) {
    delegate.attach(attachables);
  }

  @Override
  public  LoaderOptionsStep loadInto(Table table) {
    return delegate.loadInto(table);
  }

  @Override
  public Query query(SQL sql) {
    return delegate.query(sql);
  }

  @Override
  public Query query(String sql) {
    return delegate.query(sql);
  }

  @Override
  public Query query(String sql, Object... bindings) {
    return delegate.query(sql, bindings);
  }

  @Override
  public Query query(String sql, QueryPart... parts) {
    return delegate.query(sql, parts);
  }

  @Override
  public Result fetch(SQL sql) throws DataAccessException {
    return delegate.fetch(sql);
  }

  @Override
  public Result fetch(String sql) throws DataAccessException {
    return delegate.fetch(sql);
  }

  @Override
  public Result fetch(String sql, Object... bindings) throws DataAccessException {
    return delegate.fetch(sql, bindings);
  }

  @Override
  public Result fetch(String sql, QueryPart... parts) throws DataAccessException {
    return delegate.fetch(sql, parts);
  }

  @Override
  public Cursor fetchLazy(SQL sql) throws DataAccessException {
    return delegate.fetchLazy(sql);
  }

  @Override
  public Cursor fetchLazy(String sql) throws DataAccessException {
    return delegate.fetchLazy(sql);
  }

  @Override
  public Cursor fetchLazy(String sql, Object... bindings) throws DataAccessException {
    return delegate.fetchLazy(sql, bindings);
  }

  @Override
  public Cursor fetchLazy(String sql, QueryPart... parts) throws DataAccessException {
    return delegate.fetchLazy(sql, parts);
  }

  @Override
  public CompletionStage> fetchAsync(SQL sql) {
    return delegate.fetchAsync(sql);
  }

  @Override
  public CompletionStage> fetchAsync(String sql) {
    return delegate.fetchAsync(sql);
  }

  @Override
  public CompletionStage> fetchAsync(String sql, Object... bindings) {
    return delegate.fetchAsync(sql, bindings);
  }

  @Override
  public CompletionStage> fetchAsync(String sql, QueryPart... parts) {
    return delegate.fetchAsync(sql, parts);
  }

  @Override
  public CompletionStage> fetchAsync(Executor executor, SQL sql) {
    return delegate.fetchAsync(executor, sql);
  }

  @Override
  public CompletionStage> fetchAsync(Executor executor, String sql) {
    return delegate.fetchAsync(executor, sql);
  }

  @Override
  public CompletionStage> fetchAsync(Executor executor, String sql, Object... bindings) {
    return delegate.fetchAsync(executor, sql, bindings);
  }

  @Override
  public CompletionStage> fetchAsync(Executor executor, String sql, QueryPart... parts) {
    return delegate.fetchAsync(executor, sql, parts);
  }

  @Override
  public Stream fetchStream(SQL sql) throws DataAccessException {
    return delegate.fetchStream(sql);
  }

  @Override
  public Stream fetchStream(String sql) throws DataAccessException {
    return delegate.fetchStream(sql);
  }

  @Override
  public Stream fetchStream(String sql, Object... bindings) throws DataAccessException {
    return delegate.fetchStream(sql, bindings);
  }

  @Override
  public Stream fetchStream(String sql, QueryPart... parts) throws DataAccessException {
    return delegate.fetchStream(sql, parts);
  }

  @Override
  public Results fetchMany(SQL sql) throws DataAccessException {
    return delegate.fetchMany(sql);
  }

  @Override
  public Results fetchMany(String sql) throws DataAccessException {
    return delegate.fetchMany(sql);
  }

  @Override
  public Results fetchMany(String sql, Object... bindings) throws DataAccessException {
    return delegate.fetchMany(sql, bindings);
  }

  @Override
  public Results fetchMany(String sql, QueryPart... parts) throws DataAccessException {
    return delegate.fetchMany(sql, parts);
  }

  @Override
  public Record fetchOne(SQL sql) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOne(sql);
  }

  @Override
  public Record fetchOne(String sql) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOne(sql);
  }

  @Override
  public Record fetchOne(String sql, Object... bindings) throws DataAccessException,
      TooManyRowsException {
    return delegate.fetchOne(sql, bindings);
  }

  @Override
  public Record fetchOne(String sql, QueryPart... parts) throws DataAccessException,
      TooManyRowsException {
    return delegate.fetchOne(sql, parts);
  }

  @Override
  public Optional fetchOptional(SQL sql) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOptional(sql);
  }

  @Override
  public Optional fetchOptional(String sql) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOptional(sql);
  }

  @Override
  public Optional fetchOptional(String sql, Object... bindings) throws DataAccessException,
      TooManyRowsException {
    return delegate.fetchOptional(sql, bindings);
  }

  @Override
  public Optional fetchOptional(String sql, QueryPart... parts) throws DataAccessException,
      TooManyRowsException {
    return delegate.fetchOptional(sql, parts);
  }

  @Override
  public Object fetchValue(SQL sql) throws DataAccessException, TooManyRowsException,
      InvalidResultException {
    return delegate.fetchValue(sql);
  }

  @Override
  public Object fetchValue(String sql) throws DataAccessException, TooManyRowsException,
      InvalidResultException {
    return delegate.fetchValue(sql);
  }

  @Override
  public Object fetchValue(String sql, Object... bindings) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchValue(sql, bindings);
  }

  @Override
  public Object fetchValue(String sql, QueryPart... parts) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchValue(sql, parts);
  }

  @Override
  public Optional fetchOptionalValue(SQL sql) throws DataAccessException, TooManyRowsException,
      InvalidResultException {
    return delegate.fetchOptionalValue(sql);
  }

  @Override
  public Optional fetchOptionalValue(String sql) throws DataAccessException, TooManyRowsException,
      InvalidResultException {
    return delegate.fetchOptionalValue(sql);
  }

  @Override
  public Optional fetchOptionalValue(String sql, Object... bindings) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchOptionalValue(sql, bindings);
  }

  @Override
  public Optional fetchOptionalValue(String sql, QueryPart... parts) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchOptionalValue(sql, parts);
  }

  @Override
  public List fetchValues(SQL sql) throws DataAccessException {
    return delegate.fetchValues(sql);
  }

  @Override
  public List fetchValues(String sql) throws DataAccessException {
    return delegate.fetchValues(sql);
  }

  @Override
  public List fetchValues(String sql, Object... bindings) throws DataAccessException {
    return delegate.fetchValues(sql, bindings);
  }

  @Override
  public List fetchValues(String sql, QueryPart... parts) throws DataAccessException {
    return delegate.fetchValues(sql, parts);
  }

  @Override
  public int execute(SQL sql) throws DataAccessException {
    return delegate.execute(sql);
  }

  @Override
  public int execute(String sql) throws DataAccessException {
    return delegate.execute(sql);
  }

  @Override
  public int execute(String sql, Object... bindings) throws DataAccessException {
    return delegate.execute(sql, bindings);
  }

  @Override
  public int execute(String sql, QueryPart... parts) throws DataAccessException {
    return delegate.execute(sql, parts);
  }

  @Override
  public ResultQuery resultQuery(SQL sql) {
    return delegate.resultQuery(sql);
  }

  @Override
  public ResultQuery resultQuery(String sql) {
    return delegate.resultQuery(sql);
  }

  @Override
  public ResultQuery resultQuery(String sql, Object... bindings) {
    return delegate.resultQuery(sql, bindings);
  }

  @Override
  public ResultQuery resultQuery(String sql, QueryPart... parts) {
    return delegate.resultQuery(sql, parts);
  }

  @Override
  public Result fetch(ResultSet rs) throws DataAccessException {
    return delegate.fetch(rs);
  }

  @Override
  public Result fetch(ResultSet rs,
      Field... fields) throws DataAccessException {
    return delegate.fetch(rs, fields);
  }

  @Override
  public Result fetch(ResultSet rs,
      DataType... types) throws DataAccessException {
    return delegate.fetch(rs, types);
  }

  @Override
  public Result fetch(ResultSet rs,
      Class... types) throws DataAccessException {
    return delegate.fetch(rs, types);
  }

  @Override
  public Record fetchOne(ResultSet rs) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOne(rs);
  }

  @Override
  public Record fetchOne(ResultSet rs,
      Field... fields) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOne(rs, fields);
  }

  @Override
  public Record fetchOne(ResultSet rs,
      DataType... types) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOne(rs, types);
  }

  @Override
  public Record fetchOne(ResultSet rs,
      Class... types) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOne(rs, types);
  }

  @Override
  public Optional fetchOptional(ResultSet rs) throws DataAccessException,
      TooManyRowsException {
    return delegate.fetchOptional(rs);
  }

  @Override
  public Optional fetchOptional(ResultSet rs,
      Field... fields) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOptional(rs, fields);
  }

  @Override
  public Optional fetchOptional(ResultSet rs,
      DataType... types) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOptional(rs, types);
  }

  @Override
  public Optional fetchOptional(ResultSet rs,
      Class... types) throws DataAccessException, TooManyRowsException {
    return delegate.fetchOptional(rs, types);
  }

  @Override
  public Object fetchValue(ResultSet rs) throws DataAccessException, TooManyRowsException,
      InvalidResultException {
    return delegate.fetchValue(rs);
  }

  @Override
  public  T fetchValue(ResultSet rs, Field field) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchValue(rs, field);
  }

  @Override
  public  T fetchValue(ResultSet rs, DataType type) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchValue(rs, type);
  }

  @Override
  public  T fetchValue(ResultSet rs, Class type) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchValue(rs, type);
  }

  @Override
  public Optional fetchOptionalValue(ResultSet rs) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchOptionalValue(rs);
  }

  @Override
  public  Optional fetchOptionalValue(ResultSet rs, Field field) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchOptionalValue(rs, field);
  }

  @Override
  public  Optional fetchOptionalValue(ResultSet rs, DataType type) throws
      DataAccessException, TooManyRowsException, InvalidResultException {
    return delegate.fetchOptionalValue(rs, type);
  }

  @Override
  public  Optional fetchOptionalValue(ResultSet rs, Class type) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchOptionalValue(rs, type);
  }

  @Override
  public List fetchValues(ResultSet rs) throws DataAccessException {
    return delegate.fetchValues(rs);
  }

  @Override
  public  List fetchValues(ResultSet rs, Field field) throws DataAccessException {
    return delegate.fetchValues(rs, field);
  }

  @Override
  public  List fetchValues(ResultSet rs, DataType type) throws DataAccessException {
    return delegate.fetchValues(rs, type);
  }

  @Override
  public  List fetchValues(ResultSet rs, Class type) throws DataAccessException {
    return delegate.fetchValues(rs, type);
  }

  @Override
  public Cursor fetchLazy(ResultSet rs) throws DataAccessException {
    return delegate.fetchLazy(rs);
  }

  @Override
  public Cursor fetchLazy(ResultSet rs,
      Field... fields) throws DataAccessException {
    return delegate.fetchLazy(rs, fields);
  }

  @Override
  public Cursor fetchLazy(ResultSet rs,
      DataType... types) throws DataAccessException {
    return delegate.fetchLazy(rs, types);
  }

  @Override
  public Cursor fetchLazy(ResultSet rs,
      Class... types) throws DataAccessException {
    return delegate.fetchLazy(rs, types);
  }

  @Override
  public CompletionStage> fetchAsync(ResultSet rs) {
    return delegate.fetchAsync(rs);
  }

  @Override
  public CompletionStage> fetchAsync(ResultSet rs,
      Field... fields) {
    return delegate.fetchAsync(rs, fields);
  }

  @Override
  public CompletionStage> fetchAsync(ResultSet rs,
      DataType... types) {
    return delegate.fetchAsync(rs, types);
  }

  @Override
  public CompletionStage> fetchAsync(ResultSet rs,
      Class... types) {
    return delegate.fetchAsync(rs, types);
  }

  @Override
  public CompletionStage> fetchAsync(Executor executor, ResultSet rs) {
    return delegate.fetchAsync(executor, rs);
  }

  @Override
  public CompletionStage> fetchAsync(Executor executor, ResultSet rs,
      Field... fields) {
    return delegate.fetchAsync(executor, rs, fields);
  }

  @Override
  public CompletionStage> fetchAsync(Executor executor, ResultSet rs,
      DataType... types) {
    return delegate.fetchAsync(executor, rs, types);
  }

  @Override
  public CompletionStage> fetchAsync(Executor executor, ResultSet rs,
      Class... types) {
    return delegate.fetchAsync(executor, rs, types);
  }

  @Override
  public Stream fetchStream(ResultSet rs) throws DataAccessException {
    return delegate.fetchStream(rs);
  }

  @Override
  public Stream fetchStream(ResultSet rs,
      Field... fields) throws DataAccessException {
    return delegate.fetchStream(rs, fields);
  }

  @Override
  public Stream fetchStream(ResultSet rs,
      DataType... types) throws DataAccessException {
    return delegate.fetchStream(rs, types);
  }

  @Override
  public Stream fetchStream(ResultSet rs,
      Class... types) throws DataAccessException {
    return delegate.fetchStream(rs, types);
  }

  @Override
  public Result fetchFromTXT(String string) throws DataAccessException {
    return delegate.fetchFromTXT(string);
  }

  @Override
  public Result fetchFromTXT(String string, String nullLiteral) throws DataAccessException {
    return delegate.fetchFromTXT(string, nullLiteral);
  }

  @Override
  public Result fetchFromHTML(String string) throws DataAccessException {
    return delegate.fetchFromHTML(string);
  }

  @Override
  public Result fetchFromCSV(String string) throws DataAccessException {
    return delegate.fetchFromCSV(string);
  }

  @Override
  public Result fetchFromCSV(String string, char delimiter) throws DataAccessException {
    return delegate.fetchFromCSV(string, delimiter);
  }

  @Override
  public Result fetchFromCSV(String string, boolean header) throws DataAccessException {
    return delegate.fetchFromCSV(string, header);
  }

  @Override
  public Result fetchFromCSV(String string, boolean header, char delimiter) throws
      DataAccessException {
    return delegate.fetchFromCSV(string, header, delimiter);
  }

  @Override
  public Result fetchFromJSON(String string) {
    return delegate.fetchFromJSON(string);
  }

  @Override
  public Result fetchFromStringData(String[]... data) {
    return delegate.fetchFromStringData(data);
  }

  @Override
  public Result fetchFromStringData(List data) {
    return delegate.fetchFromStringData(data);
  }

  @Override
  public Result fetchFromStringData(List data, boolean header) {
    return delegate.fetchFromStringData(data, header);
  }

  @Override
  public WithAsStep with(String alias) {
    return delegate.with(alias);
  }

  @Override
  public WithAsStep with(String alias, String... fieldAliases) {
    return delegate.with(alias, fieldAliases);
  }

  @Override
  public WithAsStep1 with(String alias, String fieldAlias1) {
    return delegate.with(alias, fieldAlias1);
  }

  @Override
  public WithAsStep2 with(String alias, String fieldAlias1, String fieldAlias2) {
    return delegate.with(alias, fieldAlias1, fieldAlias2);
  }

  @Override
  public WithAsStep3 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3);
  }

  @Override
  public WithAsStep4 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
  }

  @Override
  public WithAsStep5 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
  }

  @Override
  public WithAsStep6 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6);
  }

  @Override
  public WithAsStep7 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7);
  }

  @Override
  public WithAsStep8 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8);
  }

  @Override
  public WithAsStep9 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
  }

  @Override
  public WithAsStep10 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
  }

  @Override
  public WithAsStep11 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
  }

  @Override
  public WithAsStep12 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
  }

  @Override
  public WithAsStep13 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13);
  }

  @Override
  public WithAsStep14 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13, String fieldAlias14) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13, fieldAlias14);
  }

  @Override
  public WithAsStep15 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13, fieldAlias14, fieldAlias15);
  }

  @Override
  public WithAsStep16 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15,
      String fieldAlias16) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
  }

  @Override
  public WithAsStep17 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15,
      String fieldAlias16, String fieldAlias17) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
  }

  @Override
  public WithAsStep18 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15,
      String fieldAlias16, String fieldAlias17, String fieldAlias18) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
  }

  @Override
  public WithAsStep19 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15,
      String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18,
        fieldAlias19);
  }

  @Override
  public WithAsStep20 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15,
      String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19,
      String fieldAlias20) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18,
        fieldAlias19, fieldAlias20);
  }

  @Override
  public WithAsStep21 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15,
      String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19,
      String fieldAlias20, String fieldAlias21) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18,
        fieldAlias19, fieldAlias20, fieldAlias21);
  }

  @Override
  public WithAsStep22 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3,
      String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7,
      String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11,
      String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15,
      String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19,
      String fieldAlias20, String fieldAlias21, String fieldAlias22) {
    return delegate.with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5,
        fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12,
        fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18,
        fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
  }

  @Override
  public WithStep with(
      CommonTableExpression... tables) {
    return delegate.with(tables);
  }

  @Override
  public WithAsStep withRecursive(String alias) {
    return delegate.withRecursive(alias);
  }

  @Override
  public WithAsStep withRecursive(String alias, String... fieldAliases) {
    return delegate.withRecursive(alias, fieldAliases);
  }

  @Override
  public WithAsStep1 withRecursive(String alias, String fieldAlias1) {
    return delegate.withRecursive(alias, fieldAlias1);
  }

  @Override
  public WithAsStep2 withRecursive(String alias, String fieldAlias1, String fieldAlias2) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2);
  }

  @Override
  public WithAsStep3 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3);
  }

  @Override
  public WithAsStep4 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
  }

  @Override
  public WithAsStep5 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5);
  }

  @Override
  public WithAsStep6 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6);
  }

  @Override
  public WithAsStep7 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7);
  }

  @Override
  public WithAsStep8 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
  }

  @Override
  public WithAsStep9 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
  }

  @Override
  public WithAsStep10 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
  }

  @Override
  public WithAsStep11 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
  }

  @Override
  public WithAsStep12 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12);
  }

  @Override
  public WithAsStep13 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13);
  }

  @Override
  public WithAsStep14 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13, fieldAlias14);
  }

  @Override
  public WithAsStep15 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14,
      String fieldAlias15) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
  }

  @Override
  public WithAsStep16 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14,
      String fieldAlias15, String fieldAlias16) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
  }

  @Override
  public WithAsStep17 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14,
      String fieldAlias15, String fieldAlias16, String fieldAlias17) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
  }

  @Override
  public WithAsStep18 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14,
      String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17,
        fieldAlias18);
  }

  @Override
  public WithAsStep19 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14,
      String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18,
      String fieldAlias19) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17,
        fieldAlias18, fieldAlias19);
  }

  @Override
  public WithAsStep20 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14,
      String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18,
      String fieldAlias19, String fieldAlias20) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17,
        fieldAlias18, fieldAlias19, fieldAlias20);
  }

  @Override
  public WithAsStep21 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14,
      String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18,
      String fieldAlias19, String fieldAlias20, String fieldAlias21) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17,
        fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
  }

  @Override
  public WithAsStep22 withRecursive(String alias, String fieldAlias1, String fieldAlias2,
      String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6,
      String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10,
      String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14,
      String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18,
      String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22) {
    return delegate.withRecursive(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4,
        fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11,
        fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17,
        fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
  }

  @Override
  public WithStep withRecursive(
      CommonTableExpression... tables) {
    return delegate.withRecursive(tables);
  }

  @Override
  public  SelectWhereStep selectFrom(Table table) {
    return delegate.selectFrom(table);
  }

  @Override
  public SelectSelectStep select(
      Collection> fields) {
    return delegate.select(fields);
  }

  @Override
  public SelectSelectStep select(
      SelectField... fields) {
    return delegate.select(fields);
  }

  @Override
  public  SelectSelectStep> select(SelectField field1) {
    return delegate.select(field1);
  }

  @Override
  public  SelectSelectStep> select(SelectField field1,
      SelectField field2) {
    return delegate.select(field1, field2);
  }

  @Override
  public  SelectSelectStep> select(SelectField field1,
      SelectField field2, SelectField field3) {
    return delegate.select(field1, field2, field3);
  }

  @Override
  public  SelectSelectStep> select(SelectField field1,
      SelectField field2, SelectField field3, SelectField field4) {
    return delegate.select(field1, field2, field3, field4);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5) {
    return delegate.select(field1, field2, field3, field4, field5);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6) {
    return delegate.select(field1, field2, field3, field4, field5, field6);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18, SelectField field19) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18, SelectField field19, SelectField field20) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19,
        field20);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18, SelectField field19, SelectField field20,
      SelectField field21) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19,
        field20, field21);
  }

  @Override
  public  SelectSelectStep> select(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18, SelectField field19, SelectField field20,
      SelectField field21, SelectField field22) {
    return delegate.select(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19,
        field20, field21, field22);
  }

  @Override
  public SelectSelectStep selectDistinct(
      Collection> fields) {
    return delegate.selectDistinct(fields);
  }

  @Override
  public SelectSelectStep selectDistinct(
      SelectField... fields) {
    return delegate.selectDistinct(fields);
  }

  @Override
  public  SelectSelectStep> selectDistinct(SelectField field1) {
    return delegate.selectDistinct(field1);
  }

  @Override
  public  SelectSelectStep> selectDistinct(SelectField field1,
      SelectField field2) {
    return delegate.selectDistinct(field1, field2);
  }

  @Override
  public  SelectSelectStep> selectDistinct(SelectField field1,
      SelectField field2, SelectField field3) {
    return delegate.selectDistinct(field1, field2, field3);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4) {
    return delegate.selectDistinct(field1, field2, field3, field4);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18, SelectField field19) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18, SelectField field19, SelectField field20) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19, field20);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18, SelectField field19, SelectField field20,
      SelectField field21) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19, field20, field21);
  }

  @Override
  public  SelectSelectStep> selectDistinct(
      SelectField field1, SelectField field2, SelectField field3, SelectField field4,
      SelectField field5, SelectField field6, SelectField field7, SelectField field8,
      SelectField field9, SelectField field10, SelectField field11,
      SelectField field12, SelectField field13, SelectField field14,
      SelectField field15, SelectField field16, SelectField field17,
      SelectField field18, SelectField field19, SelectField field20,
      SelectField field21, SelectField field22) {
    return delegate.selectDistinct(field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19, field20, field21, field22);
  }

  @Override
  public SelectSelectStep> selectZero() {
    return delegate.selectZero();
  }

  @Override
  public SelectSelectStep> selectOne() {
    return delegate.selectOne();
  }

  @Override
  public SelectSelectStep> selectCount() {
    return delegate.selectCount();
  }

  @Override
  public SelectQuery selectQuery() {
    return delegate.selectQuery();
  }

  @Override
  public  SelectQuery selectQuery(TableLike table) {
    return delegate.selectQuery(table);
  }

  @Override
  public  InsertQuery insertQuery(Table into) {
    return delegate.insertQuery(into);
  }

  @Override
  public  InsertSetStep insertInto(Table into) {
    return delegate.insertInto(into);
  }

  @Override
  public  InsertValuesStep1 insertInto(Table into, Field field1) {
    return delegate.insertInto(into, field1);
  }

  @Override
  public  InsertValuesStep2 insertInto(Table into,
      Field field1, Field field2) {
    return delegate.insertInto(into, field1, field2);
  }

  @Override
  public  InsertValuesStep3 insertInto(Table into,
      Field field1, Field field2, Field field3) {
    return delegate.insertInto(into, field1, field2, field3);
  }

  @Override
  public  InsertValuesStep4 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4) {
    return delegate.insertInto(into, field1, field2, field3, field4);
  }

  @Override
  public  InsertValuesStep5 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5);
  }

  @Override
  public  InsertValuesStep6 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6);
  }

  @Override
  public  InsertValuesStep7 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7);
  }

  @Override
  public  InsertValuesStep8 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8);
  }

  @Override
  public  InsertValuesStep9 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9);
  }

  @Override
  public  InsertValuesStep10 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10);
  }

  @Override
  public  InsertValuesStep11 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11);
  }

  @Override
  public  InsertValuesStep12 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12);
  }

  @Override
  public  InsertValuesStep13 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13);
  }

  @Override
  public  InsertValuesStep14 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14);
  }

  @Override
  public  InsertValuesStep15 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15);
  }

  @Override
  public  InsertValuesStep16 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16);
  }

  @Override
  public  InsertValuesStep17 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17);
  }

  @Override
  public  InsertValuesStep18 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18);
  }

  @Override
  public  InsertValuesStep19 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18, Field field19) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19);
  }

  @Override
  public  InsertValuesStep20 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18, Field field19, Field field20) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19, field20);
  }

  @Override
  public  InsertValuesStep21 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18, Field field19, Field field20, Field field21) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19, field20, field21);
  }

  @Override
  public  InsertValuesStep22 insertInto(
      Table into, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18, Field field19, Field field20, Field field21,
      Field field22) {
    return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19, field20, field21, field22);
  }

  @Override
  public  InsertValuesStepN insertInto(Table into,
      Field... fields) {
    return delegate.insertInto(into, fields);
  }

  @Override
  public  InsertValuesStepN insertInto(Table into,
      Collection> fields) {
    return delegate.insertInto(into, fields);
  }

  @Override
  public  UpdateQuery updateQuery(Table table) {
    return delegate.updateQuery(table);
  }

  @Override
  public  UpdateSetFirstStep update(Table table) {
    return delegate.update(table);
  }

  @Override
  public  MergeUsingStep mergeInto(Table table) {
    return delegate.mergeInto(table);
  }

  @Override
  public  MergeKeyStep1 mergeInto(Table table, Field field1) {
    return delegate.mergeInto(table, field1);
  }

  @Override
  public  MergeKeyStep2 mergeInto(Table table,
      Field field1, Field field2) {
    return delegate.mergeInto(table, field1, field2);
  }

  @Override
  public  MergeKeyStep3 mergeInto(Table table,
      Field field1, Field field2, Field field3) {
    return delegate.mergeInto(table, field1, field2, field3);
  }

  @Override
  public  MergeKeyStep4 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4) {
    return delegate.mergeInto(table, field1, field2, field3, field4);
  }

  @Override
  public  MergeKeyStep5 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5);
  }

  @Override
  public  MergeKeyStep6 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6);
  }

  @Override
  public  MergeKeyStep7 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7);
  }

  @Override
  public  MergeKeyStep8 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8);
  }

  @Override
  public  MergeKeyStep9 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9);
  }

  @Override
  public  MergeKeyStep10 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10);
  }

  @Override
  public  MergeKeyStep11 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11);
  }

  @Override
  public  MergeKeyStep12 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12);
  }

  @Override
  public  MergeKeyStep13 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13);
  }

  @Override
  public  MergeKeyStep14 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14);
  }

  @Override
  public  MergeKeyStep15 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15);
  }

  @Override
  public  MergeKeyStep16 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16);
  }

  @Override
  public  MergeKeyStep17 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17);
  }

  @Override
  public  MergeKeyStep18 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18);
  }

  @Override
  public  MergeKeyStep19 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18, Field field19) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19);
  }

  @Override
  public  MergeKeyStep20 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18, Field field19, Field field20) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19, field20);
  }

  @Override
  public  MergeKeyStep21 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18, Field field19, Field field20, Field field21) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19, field20, field21);
  }

  @Override
  public  MergeKeyStep22 mergeInto(
      Table table, Field field1, Field field2, Field field3, Field field4,
      Field field5, Field field6, Field field7, Field field8, Field field9,
      Field field10, Field field11, Field field12, Field field13,
      Field field14, Field field15, Field field16, Field field17,
      Field field18, Field field19, Field field20, Field field21,
      Field field22) {
    return delegate.mergeInto(table, field1, field2, field3, field4, field5, field6, field7, field8,
        field9, field10, field11, field12, field13, field14, field15, field16, field17, field18,
        field19, field20, field21, field22);
  }

  @Override
  public  MergeKeyStepN mergeInto(Table table,
      Field... fields) {
    return delegate.mergeInto(table, fields);
  }

  @Override
  public  MergeKeyStepN mergeInto(Table table,
      Collection> fields) {
    return delegate.mergeInto(table, fields);
  }

  @Override
  public  DeleteQuery deleteQuery(Table table) {
    return delegate.deleteQuery(table);
  }

  @Override
  public  DeleteWhereStep deleteFrom(Table table) {
    return delegate.deleteFrom(table);
  }

  @Override
  public  DeleteWhereStep delete(Table table) {
    return delegate.delete(table);
  }

  @Override
  public Batch batch(Query... queries) {
    return delegate.batch(queries);
  }

  @Override
  public Batch batch(Queries queries) {
    return delegate.batch(queries);
  }

  @Override
  public Batch batch(String... queries) {
    return delegate.batch(queries);
  }

  @Override
  public Batch batch(
      Collection queries) {
    return delegate.batch(queries);
  }

  @Override
  public BatchBindStep batch(Query query) {
    return delegate.batch(query);
  }

  @Override
  public BatchBindStep batch(String sql) {
    return delegate.batch(sql);
  }

  @Override
  public Batch batch(Query query, Object[]... bindings) {
    return delegate.batch(query, bindings);
  }

  @Override
  public Batch batch(String sql, Object[]... bindings) {
    return delegate.batch(sql, bindings);
  }

  @Override
  public Batch batchStore(
      UpdatableRecord... records) {
    return delegate.batchStore(records);
  }

  @Override
  public Batch batchStore(
      Collection> records) {
    return delegate.batchStore(records);
  }

  @Override
  public Batch batchInsert(
      TableRecord... records) {
    return delegate.batchInsert(records);
  }

  @Override
  public Batch batchInsert(
      Collection> records) {
    return delegate.batchInsert(records);
  }

  @Override
  public Batch batchUpdate(
      UpdatableRecord... records) {
    return delegate.batchUpdate(records);
  }

  @Override
  public Batch batchUpdate(
      Collection> records) {
    return delegate.batchUpdate(records);
  }

  @Override
  public Batch batchDelete(
      UpdatableRecord... records) {
    return delegate.batchDelete(records);
  }

  @Override
  public Batch batchDelete(
      Collection> records) {
    return delegate.batchDelete(records);
  }

  @Override
  public Queries ddl(Schema schema) {
    return delegate.ddl(schema);
  }

  @Override
  public Queries ddl(Schema schema, DDLFlag... flags) {
    return delegate.ddl(schema, flags);
  }

  @Override
  public Queries ddl(
      Table table) {
    return delegate.ddl(table);
  }

  @Override
  public Queries ddl(
      Table table, DDLFlag... flags) {
    return delegate.ddl(table, flags);
  }

  @Override
  public CreateTableAsStep createTable(String table) {
    return delegate.createTable(table);
  }

  @Override
  public CreateTableAsStep createTable(Name table) {
    return delegate.createTable(table);
  }

  @Override
  public CreateTableAsStep createTable(
      Table table) {
    return delegate.createTable(table);
  }

  @Override
  public CreateTableAsStep createTableIfNotExists(String table) {
    return delegate.createTableIfNotExists(table);
  }

  @Override
  public CreateTableAsStep createTableIfNotExists(Name table) {
    return delegate.createTableIfNotExists(table);
  }

  @Override
  public CreateTableAsStep createTableIfNotExists(
      Table table) {
    return delegate.createTableIfNotExists(table);
  }

  @Override
  public CreateTableAsStep createTemporaryTable(String table) {
    return delegate.createTemporaryTable(table);
  }

  @Override
  public CreateTableAsStep createTemporaryTable(Name table) {
    return delegate.createTemporaryTable(table);
  }

  @Override
  public CreateTableAsStep createTemporaryTable(
      Table table) {
    return delegate.createTemporaryTable(table);
  }

  @Override
  public CreateTableAsStep createGlobalTemporaryTable(String table) {
    return delegate.createGlobalTemporaryTable(table);
  }

  @Override
  public CreateTableAsStep createGlobalTemporaryTable(Name table) {
    return delegate.createGlobalTemporaryTable(table);
  }

  @Override
  public CreateTableAsStep createGlobalTemporaryTable(
      Table table) {
    return delegate.createGlobalTemporaryTable(table);
  }

  @Override
  public CreateViewAsStep createView(String view, String... fields) {
    return delegate.createView(view, fields);
  }

  @Override
  public CreateViewAsStep createView(Name view, Name... fields) {
    return delegate.createView(view, fields);
  }

  @Override
  public CreateViewAsStep createView(
      Table view,
      Field... fields) {
    return delegate.createView(view, fields);
  }

  @Override
  public CreateViewAsStep createViewIfNotExists(String view, String... fields) {
    return delegate.createViewIfNotExists(view, fields);
  }

  @Override
  public CreateViewAsStep createViewIfNotExists(Name view, Name... fields) {
    return delegate.createViewIfNotExists(view, fields);
  }

  @Override
  public CreateViewAsStep createViewIfNotExists(
      Table view,
      Field... fields) {
    return delegate.createViewIfNotExists(view, fields);
  }

  @Override
  public CreateIndexStep createIndex(String index) {
    return delegate.createIndex(index);
  }

  @Override
  public CreateIndexStep createIndex(Name index) {
    return delegate.createIndex(index);
  }

  @Override
  public CreateIndexStep createIndexIfNotExists(String index) {
    return delegate.createIndexIfNotExists(index);
  }

  @Override
  public CreateIndexStep createIndexIfNotExists(Name index) {
    return delegate.createIndexIfNotExists(index);
  }

  @Override
  public CreateIndexStep createUniqueIndex(String index) {
    return delegate.createUniqueIndex(index);
  }

  @Override
  public CreateIndexStep createUniqueIndex(Name index) {
    return delegate.createUniqueIndex(index);
  }

  @Override
  public CreateIndexStep createUniqueIndexIfNotExists(String index) {
    return delegate.createUniqueIndexIfNotExists(index);
  }

  @Override
  public CreateIndexStep createUniqueIndexIfNotExists(Name index) {
    return delegate.createUniqueIndexIfNotExists(index);
  }

  @Override
  public CreateSequenceFinalStep createSequence(String sequence) {
    return delegate.createSequence(sequence);
  }

  @Override
  public CreateSequenceFinalStep createSequence(Name sequence) {
    return delegate.createSequence(sequence);
  }

  @Override
  public CreateSequenceFinalStep createSequence(
      Sequence sequence) {
    return delegate.createSequence(sequence);
  }

  @Override
  public CreateSequenceFinalStep createSequenceIfNotExists(String sequence) {
    return delegate.createSequenceIfNotExists(sequence);
  }

  @Override
  public CreateSequenceFinalStep createSequenceIfNotExists(Name sequence) {
    return delegate.createSequenceIfNotExists(sequence);
  }

  @Override
  public CreateSequenceFinalStep createSequenceIfNotExists(
      Sequence sequence) {
    return delegate.createSequenceIfNotExists(sequence);
  }

  @Override
  public AlterSequenceRestartStep alterSequence(String sequence) {
    return delegate.alterSequence(sequence);
  }

  @Override
  public AlterSequenceRestartStep alterSequence(Name sequence) {
    return delegate.alterSequence(sequence);
  }

  @Override
  public  AlterSequenceRestartStep alterSequence(Sequence sequence) {
    return delegate.alterSequence(sequence);
  }

  @Override
  public AlterTableStep alterTable(String table) {
    return delegate.alterTable(table);
  }

  @Override
  public AlterTableStep alterTable(Name table) {
    return delegate.alterTable(table);
  }

  @Override
  public AlterTableStep alterTable(
      Table table) {
    return delegate.alterTable(table);
  }

  @Override
  public DropViewFinalStep dropView(String view) {
    return delegate.dropView(view);
  }

  @Override
  public DropViewFinalStep dropView(Name view) {
    return delegate.dropView(view);
  }

  @Override
  public DropViewFinalStep dropView(
      Table view) {
    return delegate.dropView(view);
  }

  @Override
  public DropViewFinalStep dropViewIfExists(String view) {
    return delegate.dropViewIfExists(view);
  }

  @Override
  public DropViewFinalStep dropViewIfExists(Name view) {
    return delegate.dropViewIfExists(view);
  }

  @Override
  public DropViewFinalStep dropViewIfExists(
      Table view) {
    return delegate.dropViewIfExists(view);
  }

  @Override
  public DropTableStep dropTable(String table) {
    return delegate.dropTable(table);
  }

  @Override
  public DropTableStep dropTable(Name table) {
    return delegate.dropTable(table);
  }

  @Override
  public DropTableStep dropTable(
      Table table) {
    return delegate.dropTable(table);
  }

  @Override
  public DropTableStep dropTableIfExists(String table) {
    return delegate.dropTableIfExists(table);
  }

  @Override
  public DropTableStep dropTableIfExists(Name table) {
    return delegate.dropTableIfExists(table);
  }

  @Override
  public DropTableStep dropTableIfExists(
      Table table) {
    return delegate.dropTableIfExists(table);
  }

  @Override
  public DropIndexOnStep dropIndex(String index) {
    return delegate.dropIndex(index);
  }

  @Override
  public DropIndexOnStep dropIndex(Name index) {
    return delegate.dropIndex(index);
  }

  @Override
  public DropIndexOnStep dropIndexIfExists(String index) {
    return delegate.dropIndexIfExists(index);
  }

  @Override
  public DropIndexOnStep dropIndexIfExists(Name index) {
    return delegate.dropIndexIfExists(index);
  }

  @Override
  public DropSequenceFinalStep dropSequence(String sequence) {
    return delegate.dropSequence(sequence);
  }

  @Override
  public DropSequenceFinalStep dropSequence(Name sequence) {
    return delegate.dropSequence(sequence);
  }

  @Override
  public DropSequenceFinalStep dropSequence(
      Sequence sequence) {
    return delegate.dropSequence(sequence);
  }

  @Override
  public DropSequenceFinalStep dropSequenceIfExists(String sequence) {
    return delegate.dropSequenceIfExists(sequence);
  }

  @Override
  public DropSequenceFinalStep dropSequenceIfExists(Name sequence) {
    return delegate.dropSequenceIfExists(sequence);
  }

  @Override
  public DropSequenceFinalStep dropSequenceIfExists(
      Sequence sequence) {
    return delegate.dropSequenceIfExists(sequence);
  }

  @Override
  public TruncateIdentityStep truncate(String table) {
    return delegate.truncate(table);
  }

  @Override
  public TruncateIdentityStep truncate(Name table) {
    return delegate.truncate(table);
  }

  @Override
  public  TruncateIdentityStep truncate(Table table) {
    return delegate.truncate(table);
  }

  @Override
  public BigInteger lastID() throws DataAccessException {
    return delegate.lastID();
  }

  @Override
  public BigInteger nextval(String sequence) throws DataAccessException {
    return delegate.nextval(sequence);
  }

  @Override
  public  T nextval(Sequence sequence) throws DataAccessException {
    return delegate.nextval(sequence);
  }

  @Override
  public BigInteger currval(String sequence) throws DataAccessException {
    return delegate.currval(sequence);
  }

  @Override
  public  T currval(Sequence sequence) throws DataAccessException {
    return delegate.currval(sequence);
  }

  @Override
  public > R newRecord(UDT type) {
    return delegate.newRecord(type);
  }

  @Override
  public  R newRecord(Table table) {
    return delegate.newRecord(table);
  }

  @Override
  public  R newRecord(Table table, Object source) {
    return delegate.newRecord(table, source);
  }

  @Override
  public Record newRecord(
      Field... fields) {
    return delegate.newRecord(fields);
  }

  @Override
  public  Record1 newRecord(Field field1) {
    return delegate.newRecord(field1);
  }

  @Override
  public  Record2 newRecord(Field field1, Field field2) {
    return delegate.newRecord(field1, field2);
  }

  @Override
  public  Record3 newRecord(Field field1, Field field2,
      Field field3) {
    return delegate.newRecord(field1, field2, field3);
  }

  @Override
  public  Record4 newRecord(Field field1, Field field2,
      Field field3, Field field4) {
    return delegate.newRecord(field1, field2, field3, field4);
  }

  @Override
  public  Record5 newRecord(Field field1,
      Field field2, Field field3, Field field4, Field field5) {
    return delegate.newRecord(field1, field2, field3, field4, field5);
  }

  @Override
  public  Record6 newRecord(Field field1,
      Field field2, Field field3, Field field4, Field field5, Field field6) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6);
  }

  @Override
  public  Record7 newRecord(Field field1,
      Field field2, Field field3, Field field4, Field field5, Field field6,
      Field field7) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7);
  }

  @Override
  public  Record8 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8);
  }

  @Override
  public  Record9 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9);
  }

  @Override
  public  Record10 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10);
  }

  @Override
  public  Record11 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11);
  }

  @Override
  public  Record12 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12);
  }

  @Override
  public  Record13 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13);
  }

  @Override
  public  Record14 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14);
  }

  @Override
  public  Record15 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15);
  }

  @Override
  public  Record16 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16);
  }

  @Override
  public  Record17 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17);
  }

  @Override
  public  Record18 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18);
  }

  @Override
  public  Record19 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18,
      Field field19) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19);
  }

  @Override
  public  Record20 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18,
      Field field19, Field field20) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19,
        field20);
  }

  @Override
  public  Record21 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18,
      Field field19, Field field20, Field field21) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19,
        field20, field21);
  }

  @Override
  public  Record22 newRecord(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18,
      Field field19, Field field20, Field field21, Field field22) {
    return delegate.newRecord(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19,
        field20, field21, field22);
  }

  @Override
  public  Result newResult(Table table) {
    return delegate.newResult(table);
  }

  @Override
  public Result newResult(
      Field... fields) {
    return delegate.newResult(fields);
  }

  @Override
  public  Result> newResult(Field field1) {
    return delegate.newResult(field1);
  }

  @Override
  public  Result> newResult(Field field1, Field field2) {
    return delegate.newResult(field1, field2);
  }

  @Override
  public  Result> newResult(Field field1, Field field2,
      Field field3) {
    return delegate.newResult(field1, field2, field3);
  }

  @Override
  public  Result> newResult(Field field1,
      Field field2, Field field3, Field field4) {
    return delegate.newResult(field1, field2, field3, field4);
  }

  @Override
  public  Result> newResult(Field field1,
      Field field2, Field field3, Field field4, Field field5) {
    return delegate.newResult(field1, field2, field3, field4, field5);
  }

  @Override
  public  Result> newResult(Field field1,
      Field field2, Field field3, Field field4, Field field5, Field field6) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18,
      Field field19) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18,
      Field field19, Field field20) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19,
        field20);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18,
      Field field19, Field field20, Field field21) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19,
        field20, field21);
  }

  @Override
  public  Result> newResult(
      Field field1, Field field2, Field field3, Field field4, Field field5,
      Field field6, Field field7, Field field8, Field field9, Field field10,
      Field field11, Field field12, Field field13, Field field14,
      Field field15, Field field16, Field field17, Field field18,
      Field field19, Field field20, Field field21, Field field22) {
    return delegate.newResult(field1, field2, field3, field4, field5, field6, field7, field8, field9,
        field10, field11, field12, field13, field14, field15, field16, field17, field18, field19,
        field20, field21, field22);
  }

  @Override
  public  Result fetch(ResultQuery query) throws DataAccessException {
    return delegate.fetch(query);
  }

  @Override
  public  Cursor fetchLazy(ResultQuery query) throws DataAccessException {
    return delegate.fetchLazy(query);
  }

  @Override
  public  CompletionStage> fetchAsync(ResultQuery query) {
    return delegate.fetchAsync(query);
  }

  @Override
  public  CompletionStage> fetchAsync(Executor executor,
      ResultQuery query) {
    return delegate.fetchAsync(executor, query);
  }

  @Override
  public  Stream fetchStream(ResultQuery query) throws DataAccessException {
    return delegate.fetchStream(query);
  }

  @Override
  public  Results fetchMany(ResultQuery query) throws DataAccessException {
    return delegate.fetchMany(query);
  }

  @Override
  public  R fetchOne(ResultQuery query) throws DataAccessException,
      TooManyRowsException {
    return delegate.fetchOne(query);
  }

  @Override
  public  Optional fetchOptional(ResultQuery query) throws
      DataAccessException, TooManyRowsException {
    return delegate.fetchOptional(query);
  }

  @Override
  public > T fetchValue(ResultQuery query) throws DataAccessException,
      TooManyRowsException, InvalidResultException {
    return delegate.fetchValue(query);
  }

  @Override
  public  T fetchValue(
      TableField field) throws DataAccessException, TooManyRowsException,
      InvalidResultException {
    return delegate.fetchValue(field);
  }

  @Override
  public > Optional fetchOptionalValue(ResultQuery query) throws
      DataAccessException, TooManyRowsException, InvalidResultException {
    return delegate.fetchOptionalValue(query);
  }

  @Override
  public  Optional fetchOptionalValue(
      TableField field) throws DataAccessException, TooManyRowsException,
      InvalidResultException {
    return delegate.fetchOptionalValue(field);
  }

  @Override
  public > List fetchValues(ResultQuery query) throws
      DataAccessException {
    return delegate.fetchValues(query);
  }

  @Override
  public  List fetchValues(
      TableField field) throws DataAccessException {
    return delegate.fetchValues(field);
  }

  @Override
  public int fetchCount(
      Select query) throws DataAccessException {
    return delegate.fetchCount(query);
  }

  @Override
  public int fetchCount(
      Table table) throws DataAccessException {
    return delegate.fetchCount(table);
  }

  @Override
  public int fetchCount(
      Table table, Condition condition) throws DataAccessException {
    return delegate.fetchCount(table, condition);
  }

  @Override
  public boolean fetchExists(
      Select query) throws DataAccessException {
    return delegate.fetchExists(query);
  }

  @Override
  public boolean fetchExists(
      Table table) throws DataAccessException {
    return delegate.fetchExists(table);
  }

  @Override
  public boolean fetchExists(
      Table table, Condition condition) throws DataAccessException {
    return delegate.fetchExists(table, condition);
  }

  @Override
  public int execute(Query query) throws DataAccessException {
    return delegate.execute(query);
  }

  @Override
  public  Result fetch(Table table) throws DataAccessException {
    return delegate.fetch(table);
  }

  @Override
  public  Result fetch(Table table, Condition condition) throws
      DataAccessException {
    return delegate.fetch(table, condition);
  }

  @Override
  public  R fetchOne(Table table) throws DataAccessException,
      TooManyRowsException {
    return delegate.fetchOne(table);
  }

  @Override
  public  R fetchOne(Table table, Condition condition) throws
      DataAccessException, TooManyRowsException {
    return delegate.fetchOne(table, condition);
  }

  @Override
  public  Optional fetchOptional(Table table) throws DataAccessException,
      TooManyRowsException {
    return delegate.fetchOptional(table);
  }

  @Override
  public  Optional fetchOptional(Table table, Condition condition) throws
      DataAccessException, TooManyRowsException {
    return delegate.fetchOptional(table, condition);
  }

  @Override
  public  R fetchAny(Table table) throws DataAccessException {
    return delegate.fetchAny(table);
  }

  @Override
  public  R fetchAny(Table table, Condition condition) throws
      DataAccessException {
    return delegate.fetchAny(table, condition);
  }

  @Override
  public  Cursor fetchLazy(Table table) throws DataAccessException {
    return delegate.fetchLazy(table);
  }

  @Override
  public  Cursor fetchLazy(Table table, Condition condition) throws
      DataAccessException {
    return delegate.fetchLazy(table, condition);
  }

  @Override
  public  CompletionStage> fetchAsync(Table table) {
    return delegate.fetchAsync(table);
  }

  @Override
  public  CompletionStage> fetchAsync(Table table,
      Condition condition) {
    return delegate.fetchAsync(table, condition);
  }

  @Override
  public  CompletionStage> fetchAsync(Executor executor, Table table) {
    return delegate.fetchAsync(executor, table);
  }

  @Override
  public  CompletionStage> fetchAsync(Executor executor, Table table,
      Condition condition) {
    return delegate.fetchAsync(executor, table, condition);
  }

  @Override
  public  Stream fetchStream(Table table) throws DataAccessException {
    return delegate.fetchStream(table);
  }

  @Override
  public  Stream fetchStream(Table table, Condition condition) throws
      DataAccessException {
    return delegate.fetchStream(table, condition);
  }

  @Override
  public > int executeInsert(R record) throws DataAccessException {
    return delegate.executeInsert(record);
  }

  @Override
  public > int executeUpdate(R record) throws DataAccessException {
    return delegate.executeUpdate(record);
  }

  @Override
  public , T> int executeUpdate(R record, Condition condition) throws
      DataAccessException {
    return delegate.executeUpdate(record, condition);
  }

  @Override
  public > int executeDelete(R record) throws DataAccessException {
    return delegate.executeDelete(record);
  }

  @Override
  public , T> int executeDelete(R record, Condition condition) throws
      DataAccessException {
    return delegate.executeDelete(record, condition);
  }

  @Override
  public Configuration configuration() {
    return delegate.configuration();
  }

  @Override
  public Settings settings() {
    return delegate.settings();
  }

  @Override
  public SQLDialect dialect() {
    return delegate.dialect();
  }

  @Override
  public SQLDialect family() {
    return delegate.family();
  }

  @Override
  public Map data() {
    return delegate.data();
  }

  @Override
  public Object data(Object key) {
    return delegate.data(key);
  }

  @Override
  public Object data(Object key, Object value) {
    return delegate.data(key, value);
  }
}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy