http://www.jooq.org/jooq: jOOQ effectively combines complex SQL, typesafety, source code generation, active records,
stored procedures, advanced data types, and Java in a fluent, intuitive DSL.
/*
* 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.
*
* Other licenses:
* -----------------------------------------------------------------------------
* Commercial licenses for this work are available. These replace the above
* ASL 2.0 and offer limited warranties, support, maintenance, and commercial
* database integrations.
*
* For more information, please visit: http://www.jooq.org/licenses
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package org.jooq;
// ...
// ...
// ...
import static org.jooq.SQLDialect.CUBRID;
// ...
import static org.jooq.SQLDialect.DERBY;
import static org.jooq.SQLDialect.H2;
// ...
import static org.jooq.SQLDialect.HSQLDB;
// ...
// ...
import static org.jooq.SQLDialect.MARIADB;
// ...
// ...
// ...
import static org.jooq.SQLDialect.POSTGRES;
// ...
import static org.jooq.SQLDialect.SQLITE;
// ...
// ...
// ...
// ...
import java.util.List;
import org.jooq.exception.DataAccessException;
import org.jooq.impl.DSL;
import org.jetbrains.annotations.NotNull;
A SELECT statement.
Example:
// Assuming import static org.jooq.impl.DSL.*;
using(configuration)
.select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME)
.from(ACTOR)
.fetch();
Instances can be created using DSL.select(SelectFieldOrAsterisk...), or DSLContext.selectQuery() and overloads.
Author: Lukas Eder Type parameters: - <R> – The record type being returned by this query
/**
* A <code>SELECT</code> statement.
* <p>
* <strong>Example:</strong>
* <p>
* <code><pre>
* // Assuming import static org.jooq.impl.DSL.*;
*
* using(configuration)
* .select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME)
* .from(ACTOR)
* .fetch();
* </pre></code>
* <p>
* Instances can be created using {@link DSL#select(SelectFieldOrAsterisk...)},
* or {@link DSLContext#selectQuery()} and overloads.
*
* @param <R> The record type being returned by this query
* @author Lukas Eder
*/
public interface Select<R extends Record> extends ResultQuery<R>, TableLike<R>, FieldLike {
Apply the UNION set operation.
Throws: - IllegalArgumentException – If the argument select has the same identity as this select. The jOOQ 3.x API is mutable, which means that calls to the DSL API mutate this instance. Adding this instance as an set operation argument would lead to a
StackOverflowError when generating the SQL.
/**
* Apply the <code>UNION</code> set operation.
*
* @throws IllegalArgumentException If the argument select has the same
* identity as this select. The jOOQ 3.x API is mutable, which
* means that calls to the DSL API mutate this instance. Adding
* this instance as an set operation argument would lead to a
* {@link StackOverflowError} when generating the SQL.
*/
@NotNull
@Support
Select<R> union(Select<? extends R> select);
Apply the UNION ALL set operation.
Throws: - IllegalArgumentException – If the argument select has the same identity as this select. The jOOQ 3.x API is mutable, which means that calls to the DSL API mutate this instance. Adding this instance as an set operation argument would lead to a
StackOverflowError when generating the SQL.
/**
* Apply the <code>UNION ALL</code> set operation.
*
* @throws IllegalArgumentException If the argument select has the same
* identity as this select. The jOOQ 3.x API is mutable, which
* means that calls to the DSL API mutate this instance. Adding
* this instance as an set operation argument would lead to a
* {@link StackOverflowError} when generating the SQL.
*/
@NotNull
@Support
Select<R> unionAll(Select<? extends R> select);
Apply the EXCEPT (or MINUS) set operation.
Throws: - IllegalArgumentException – If the argument select has the same identity as this select. The jOOQ 3.x API is mutable, which means that calls to the DSL API mutate this instance. Adding this instance as an set operation argument would lead to a
StackOverflowError when generating the SQL.
/**
* Apply the <code>EXCEPT</code> (or <code>MINUS</code>) set operation.
*
* @throws IllegalArgumentException If the argument select has the same
* identity as this select. The jOOQ 3.x API is mutable, which
* means that calls to the DSL API mutate this instance. Adding
* this instance as an set operation argument would lead to a
* {@link StackOverflowError} when generating the SQL.
*/
@NotNull
@Support({ CUBRID, DERBY, H2, HSQLDB, MARIADB, POSTGRES, SQLITE })
Select<R> except(Select<? extends R> select);
Apply the EXCEPT ALL set operation.
Throws: - IllegalArgumentException – If the argument select has the same identity as this select. The jOOQ 3.x API is mutable, which means that calls to the DSL API mutate this instance. Adding this instance as an set operation argument would lead to a
StackOverflowError when generating the SQL.
/**
* Apply the <code>EXCEPT ALL</code> set operation.
*
* @throws IllegalArgumentException If the argument select has the same
* identity as this select. The jOOQ 3.x API is mutable, which
* means that calls to the DSL API mutate this instance. Adding
* this instance as an set operation argument would lead to a
* {@link StackOverflowError} when generating the SQL.
*/
@NotNull
@Support({ CUBRID, DERBY, HSQLDB, POSTGRES })
Select<R> exceptAll(Select<? extends R> select);
Apply the INTERSECT set operation.
Throws: - IllegalArgumentException – If the argument select has the same identity as this select. The jOOQ 3.x API is mutable, which means that calls to the DSL API mutate this instance. Adding this instance as an set operation argument would lead to a
StackOverflowError when generating the SQL.
/**
* Apply the <code>INTERSECT</code> set operation.
*
* @throws IllegalArgumentException If the argument select has the same
* identity as this select. The jOOQ 3.x API is mutable, which
* means that calls to the DSL API mutate this instance. Adding
* this instance as an set operation argument would lead to a
* {@link StackOverflowError} when generating the SQL.
*/
@NotNull
@Support({ CUBRID, DERBY, H2, HSQLDB, MARIADB, POSTGRES, SQLITE })
Select<R> intersect(Select<? extends R> select);
Apply the INTERSECT ALL set operation.
Throws: - IllegalArgumentException – If the argument select has the same identity as this select. The jOOQ 3.x API is mutable, which means that calls to the DSL API mutate this instance. Adding this instance as an set operation argument would lead to a
StackOverflowError when generating the SQL.
/**
* Apply the <code>INTERSECT ALL</code> set operation.
*
* @throws IllegalArgumentException If the argument select has the same
* identity as this select. The jOOQ 3.x API is mutable, which
* means that calls to the DSL API mutate this instance. Adding
* this instance as an set operation argument would lead to a
* {@link StackOverflowError} when generating the SQL.
*/
@NotNull
@Support({ CUBRID, DERBY, HSQLDB, POSTGRES })
Select<R> intersectAll(Select<? extends R> select);
All fields selected in this query
/**
* All fields selected in this query
*/
@NotNull
List<Field<?>> getSelect();
Execute this query in the context of its attached executor and return a
COUNT(*) value.
This wraps a pre-existing SELECT query in another one to
calculate the COUNT(*) value, without modifying the original
SELECT. An example:
-- Original query:
SELECT id, title FROM book WHERE title LIKE '%a%'
-- Wrapped query:
SELECT count(*) FROM (
SELECT id, title FROM book WHERE title LIKE '%a%'
)
This is particularly useful for those databases that do not
support the COUNT(*) OVER() window function to calculate
total results in paged queries.
Throws: - DataAccessException – if something went wrong executing the query
Returns: The COUNT(*) result Deprecated: - 3.5.0 - [#3356] - This method is being removed as it is confusingly different from all the other types of ResultQuery.fetch() methods, in that it modifies the original Select statement by wrapping it. In particular, this method can be easily confused with ResultQuery.fetch(Field), or more concretely fetch(count()), which has an entirely different semantics. Use DSLContext.fetchCount(Select<?>) instead.
/**
* Execute this query in the context of its attached executor and return a
* <code>COUNT(*)</code> value.
* <p>
* This wraps a pre-existing <code>SELECT</code> query in another one to
* calculate the <code>COUNT(*)</code> value, without modifying the original
* <code>SELECT</code>. An example: <code><pre>
* -- Original query:
* SELECT id, title FROM book WHERE title LIKE '%a%'
*
* -- Wrapped query:
* SELECT count(*) FROM (
* SELECT id, title FROM book WHERE title LIKE '%a%'
* )
* </pre></code> This is particularly useful for those databases that do not
* support the <code>COUNT(*) OVER()</code> window function to calculate
* total results in paged queries.
*
* @return The <code>COUNT(*)</code> result
* @throws DataAccessException if something went wrong executing the query
* @deprecated - 3.5.0 - [#3356] - This method is being removed as it is
* confusingly different from all the other types of
* {@link #fetch()} methods, in that it modifies the original
* {@link Select} statement by wrapping it. In particular, this
* method can be easily confused with {@link #fetch(Field)}, or
* more concretely <code>fetch(count())</code>, which has an
* entirely different semantics. Use
* {@link DSLContext#fetchCount(Select)} instead.
*/
@Deprecated
int fetchCount() throws DataAccessException;
}