org.jooq.WithStep Maven / Gradle / Ivy
/**
* Copyright (c) 2009-2014, Data Geekery GmbH (http://www.datageekery.com)
* All rights reserved.
*
* This work is dual-licensed
* - under the Apache Software License 2.0 (the "ASL")
* - under the jOOQ License and Maintenance Agreement (the "jOOQ License")
* =============================================================================
* You may choose which license applies to you:
*
* - If you're using this work with Open Source databases, you may choose
* either ASL or jOOQ License.
* - If you're using this work with at least one commercial database, you must
* choose jOOQ License
*
* For more information, please visit http://www.jooq.org/licenses
*
* Apache Software License 2.0:
* -----------------------------------------------------------------------------
* 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.
*
* jOOQ License and Maintenance Agreement:
* -----------------------------------------------------------------------------
* Data Geekery grants the Customer the non-exclusive, timely limited and
* non-transferable license to install and use the Software under the terms of
* the jOOQ License and Maintenance Agreement.
*
* This library is distributed with a LIMITED WARRANTY. See the jOOQ License
* and Maintenance Agreement for more details: http://www.jooq.org/licensing
*/
package org.jooq;
import static org.jooq.SQLDialect.CUBRID;
// ...
import static org.jooq.SQLDialect.FIREBIRD;
import static org.jooq.SQLDialect.H2;
import static org.jooq.SQLDialect.HSQLDB;
// ...
import static org.jooq.SQLDialect.POSTGRES;
// ...
// ...
import java.util.Collection;
import javax.annotation.Generated;
import org.jooq.impl.DSL;
/**
* This type is part of the jOOQ DSL to create {@link Select}, {@link Insert},
* {@link Update}, {@link Delete}, {@link Merge} statements prefixed with a
* WITH clause and with {@link CommonTableExpression}s.
*
* Example:
*
* DSL.with("table", "col1", "col2")
* .as(
* select(one(), two())
* )
* .select()
* .from("table")
* WITH clause.
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
WithAsStep with(String alias);
/**
* Add another common table expression to the WITH clause.
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
WithAsStep with(String alias, String... fieldAliases);
/**
* Add another common table expression to the WITH clause.
*
* Reusable {@link CommonTableExpression} types can be constructed through
*
* - {@link DSL#name(String...)}
* - {@link Name#fields(String...)}
* -
* {@link DerivedColumnList#as(Select)}
*
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
WithStep with(CommonTableExpression... tables);
// -------------------------------------------------------------------------
// XXX Continue with the actual INSERT, UPDATE, DELETE, SELECT statement type
// -------------------------------------------------------------------------
/**
* Create a new DSL select statement.
*
* Example:
* SELECT * FROM [table] WHERE [conditions] ORDER BY [ordering] LIMIT [limit clause]
* SelectWhereStep selectFrom(Table table);
/**
* Create a new DSL select statement.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Collection)} instead.
*
* Example:
* DSLContext create = DSL.using(configuration);
*
* create.select(fields)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* select(Collection> fields);
/**
* Create a new DSL select statement.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field...)} instead.
*
* Example:
* DSLContext create = DSL.using(configuration);
*
* create.select(field1, field2)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2)
* .execute();
* select(Field... fields);
// [jooq-tools] START [select]
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Field#in(Select)}, {@link Field#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(field1).as(subselect))
* .select(field1)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row2#in(Select)}, {@link Row2#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(field1, field2).as(subselect))
* .select(field1, field2)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row3#in(Select)}, {@link Row3#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(field1, field2, field3).as(subselect))
* .select(field1, field2, field3)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row4#in(Select)}, {@link Row4#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(field1, field2, field3, field4).as(subselect))
* .select(field1, field2, field3, field4)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row5#in(Select)}, {@link Row5#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(field1, field2, field3, field4, field5).as(subselect))
* .select(field1, field2, field3, field4, field5)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row6#in(Select)}, {@link Row6#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f5, f6).as(subselect))
* .select(field1, field2, field3, .., field5, field6)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row7#in(Select)}, {@link Row7#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f6, f7).as(subselect))
* .select(field1, field2, field3, .., field6, field7)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row8#in(Select)}, {@link Row8#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f7, f8).as(subselect))
* .select(field1, field2, field3, .., field7, field8)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row9#in(Select)}, {@link Row9#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f8, f9).as(subselect))
* .select(field1, field2, field3, .., field8, field9)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row10#in(Select)}, {@link Row10#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f9, f10).as(subselect))
* .select(field1, field2, field3, .., field9, field10)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row11#in(Select)}, {@link Row11#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f10, f11).as(subselect))
* .select(field1, field2, field3, .., field10, field11)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row12#in(Select)}, {@link Row12#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f11, f12).as(subselect))
* .select(field1, field2, field3, .., field11, field12)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(Field field1, Field field2, Field field3, Field field4, Field field5, Field field6, Field field7, Field field8, Field field9, Field field10, Field field11, Field field12);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row13#in(Select)}, {@link Row13#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f12, f13).as(subselect))
* .select(field1, field2, field3, .., field12, field13)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(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);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row14#in(Select)}, {@link Row14#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f13, f14).as(subselect))
* .select(field1, field2, field3, .., field13, field14)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(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);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row15#in(Select)}, {@link Row15#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f14, f15).as(subselect))
* .select(field1, field2, field3, .., field14, field15)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(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);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row16#in(Select)}, {@link Row16#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f15, f16).as(subselect))
* .select(field1, field2, field3, .., field15, field16)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(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);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row17#in(Select)}, {@link Row17#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f16, f17).as(subselect))
* .select(field1, field2, field3, .., field16, field17)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(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);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row18#in(Select)}, {@link Row18#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f17, f18).as(subselect))
* .select(field1, field2, field3, .., field17, field18)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(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);
/**
* Create a new DSL select statement.
*
* This is the same as {@link #select(Field...)}, except that it
* declares additional record-level typesafety, which is needed by
* {@link Row19#in(Select)}, {@link Row19#equal(Select)} and other predicate
* building methods taking subselect arguments.
*
* This creates an attached, renderable and executable SELECT
* statement from this {@link DSLContext}. If you don't need to render or
* execute this SELECT statement (e.g. because you want to
* create a subselect), consider using the static
* {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
*
* Example:
* using(configuration)
* .with(name("t").fields(f1, f2, f3, .., f18, f19).as(subselect))
* .select(field1, field2, field3, .., field18, field19)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
* SelectSelectStep> select(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