> fetchMany(String sql, QueryPart... parts) throws DataAccessException;
/**
* Execute a new query holding plain SQL.
*
* Example (Postgres):
*
*
* String sql = "FETCH ALL IN \"\"";
*
* String sql = "pragma table_info('my_table')";
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @return The results from the executed query.
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
*/
@Support
Record fetchOne(String sql) throws DataAccessException, InvalidResultException;
/**
* Execute a new query holding plain SQL.
*
* There must be as many bind variables contained in the SQL, as passed in
* the bindings parameter
*
* Example (Postgres):
*
*
* String sql = "FETCH ALL IN \"\"";
*
* String sql = "pragma table_info('my_table')";
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @param bindings The bindings
* @return The results from the executed query. This may be
* null if the database returned no records
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
*/
@Support
Record fetchOne(String sql, Object... bindings) throws DataAccessException, InvalidResultException;
/**
* Execute a new query holding plain SQL.
*
* Unlike {@link #fetchOne(String, Object...)}, the SQL passed to this
* method should not contain any bind variables. Instead, you can pass
* {@link QueryPart} objects to the method which will be rendered at indexed
* locations of your SQL string as such:
* // The following query
* fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
*
* // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
* select ?, 'test' from "DUAL"
*
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses! One way to escape
* literals is to use {@link DSL#name(String...)} and similar methods
*
* @param sql The SQL clause, containing {numbered placeholders} where query
* parts can be injected
* @param parts The {@link QueryPart} objects that are rendered at the
* {numbered placeholder} locations
* @return The results from the executed query. This may be
* null if the database returned no records
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
*/
@Support
Record fetchOne(String sql, QueryPart... parts) throws DataAccessException, InvalidResultException;
/**
* Execute a new query holding plain SQL.
*
* Example (Postgres):
*
*
* String sql = "FETCH ALL IN \"\"";
*
* String sql = "pragma table_info('my_table')";
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @return The result value from the executed query. This may be
* null if the database returned no records
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
* or a record with more than one value.
*/
@Support
Object fetchValue(String sql) throws DataAccessException, InvalidResultException;
/**
* Execute a new query holding plain SQL.
*
* There must be as many bind variables contained in the SQL, as passed in
* the bindings parameter
*
* Example (Postgres):
*
*
* String sql = "FETCH ALL IN \"\"";
*
* String sql = "pragma table_info('my_table')";
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @param bindings The bindings
* @return The results from the executed query. This may be
* null if the database returned no records
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
* or a record with more than one value.
*/
@Support
Object fetchValue(String sql, Object... bindings) throws DataAccessException, InvalidResultException;
/**
* Execute a new query holding plain SQL.
*
* Unlike {@link #fetchValue(String, Object...)}, the SQL passed to this
* method should not contain any bind variables. Instead, you can pass
* {@link QueryPart} objects to the method which will be rendered at indexed
* locations of your SQL string as such:
* // The following query
* fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
*
* // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
* select ?, 'test' from "DUAL"
*
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses! One way to escape
* literals is to use {@link DSL#name(String...)} and similar methods
*
* @param sql The SQL clause, containing {numbered placeholders} where query
* parts can be injected
* @param parts The {@link QueryPart} objects that are rendered at the
* {numbered placeholder} locations
* @return The results from the executed query. This may be
* null if the database returned no records
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
* or a record with more than one value.
*/
@Support
Object fetchValue(String sql, QueryPart... parts) throws DataAccessException, InvalidResultException;
/**
* Execute a new query holding plain SQL.
*
* Example (Postgres):
*
*
* String sql = "FETCH ALL IN \"\"";
*
* String sql = "pragma table_info('my_table')";
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @return The result values from the executed query. This is never
* null.
* @throws DataAccessException if something went wrong executing the query
*/
@Support
List fetchValues(String sql) throws DataAccessException;
/**
* Execute a new query holding plain SQL.
*
* There must be as many bind variables contained in the SQL, as passed in
* the bindings parameter
*
* Example (Postgres):
*
*
* String sql = "FETCH ALL IN \"\"";
*
* String sql = "pragma table_info('my_table')";
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @param bindings The bindings
* @return The results from the executed query. This is never
* null.
* @throws DataAccessException if something went wrong executing the query
*/
@Support
List fetchValues(String sql, Object... bindings) throws DataAccessException;
/**
* Execute a new query holding plain SQL.
*
* Unlike {@link #fetchValue(String, Object...)}, the SQL passed to this
* method should not contain any bind variables. Instead, you can pass
* {@link QueryPart} objects to the method which will be rendered at indexed
* locations of your SQL string as such:
* // The following query
* fetchOne("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
*
* // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
* select ?, 'test' from "DUAL"
*
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses! One way to escape
* literals is to use {@link DSL#name(String...)} and similar methods
*
* @param sql The SQL clause, containing {numbered placeholders} where query
* parts can be injected
* @param parts The {@link QueryPart} objects that are rendered at the
* {numbered placeholder} locations
* @return The results from the executed query. This is never
* null.
* @throws DataAccessException if something went wrong executing the query
*/
@Support
List fetchValues(String sql, QueryPart... parts) throws DataAccessException;
/**
* Execute a query holding plain SQL.
*
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @return The results from the executed query
* @throws DataAccessException if something went wrong executing the query
*/
@Support
int execute(String sql) throws DataAccessException;
/**
* Execute a new query holding plain SQL.
*
* There must be as many bind variables contained in the SQL, as passed in
* the bindings parameter
*
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @param bindings The bindings
* @return The results from the executed query
* @throws DataAccessException if something went wrong executing the query
*/
@Support
int execute(String sql, Object... bindings) throws DataAccessException;
/**
* Execute a new query holding plain SQL.
*
* Unlike {@link #execute(String, Object...)}, the SQL passed to this method
* should not contain any bind variables. Instead, you can pass
* {@link QueryPart} objects to the method which will be rendered at indexed
* locations of your SQL string as such:
* // The following query
* execute("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
*
* // Will execute this SQL on an Oracle database with RenderNameStyle.QUOTED:
* select ?, 'test' from "DUAL"
*
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses! One way to escape
* literals is to use {@link DSL#name(String...)} and similar methods
*
* @param sql The SQL clause, containing {numbered placeholders} where query
* parts can be injected
* @param parts The {@link QueryPart} objects that are rendered at the
* {numbered placeholder} locations
* @return The results from the executed query
* @throws DataAccessException if something went wrong executing the query
*/
@Support
int execute(String sql, QueryPart... parts) throws DataAccessException;
/**
* Create a new query holding plain SQL.
*
* There must not be any binding variables contained in the SQL
*
* Use this method, when you want to take advantage of the many ways to
* fetch results in jOOQ, using {@link ResultQuery}. Some examples:
*
*
*
* | {@link ResultQuery#fetchLazy()} |
* Open a cursor and fetch records one by one |
*
*
* | {@link ResultQuery#fetchInto(Class)} |
* Fetch records into a custom POJO (optionally annotated with JPA
* annotations) |
*
*
* | {@link ResultQuery#fetchInto(RecordHandler)} |
* Fetch records into a custom callback (similar to Spring's RowMapper) |
*
*
*
* Example (Postgres):
*
*
* String sql = "FETCH ALL IN \"\"";
*
* String sql = "pragma table_info('my_table')";
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @return An executable query
*/
@Support
ResultQuery resultQuery(String sql);
/**
* Create a new query holding plain SQL.
*
* There must be as many bind variables contained in the SQL, as passed in
* the bindings parameter
*
* Use this method, when you want to take advantage of the many ways to
* fetch results in jOOQ, using {@link ResultQuery}. Some examples:
*
*
*
* | {@link ResultQuery#fetchLazy()} |
* Open a cursor and fetch records one by one |
*
*
* | {@link ResultQuery#fetchInto(Class)} |
* Fetch records into a custom POJO (optionally annotated with JPA
* annotations) |
*
*
* | {@link ResultQuery#fetchInto(RecordHandler)} |
* Fetch records into a custom callback (similar to Spring's RowMapper) |
*
*
*
* Example (Postgres):
*
*
* String sql = "FETCH ALL IN \"\"";
*
* String sql = "pragma table_info('my_table')";
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses!
*
* @param sql The SQL
* @param bindings The bindings
* @return A query wrapping the plain SQL
*/
@Support
ResultQuery resultQuery(String sql, Object... bindings);
/**
* Create a new query holding plain SQL.
*
* Unlike {@link #resultQuery(String, Object...)}, the SQL passed to this
* method should not contain any bind variables. Instead, you can pass
* {@link QueryPart} objects to the method which will be rendered at indexed
* locations of your SQL string as such:
* // The following query
* resultQuery("select {0}, {1} from {2}", val(1), inline("test"), name("DUAL"));
*
* // Will render this SQL on an Oracle database with RenderNameStyle.QUOTED:
* select ?, 'test' from "DUAL"
*
* NOTE: When inserting plain SQL into jOOQ objects, you must
* guarantee syntax integrity. You may also create the possibility of
* malicious SQL injection. Be sure to properly use bind variables and/or
* escape literals when concatenated into SQL clauses! One way to escape
* literals is to use {@link DSL#name(String...)} and similar methods
*
* @param sql The SQL clause, containing {numbered placeholders} where query
* parts can be injected
* @param parts The {@link QueryPart} objects that are rendered at the
* {numbered placeholder} locations
* @return A query wrapping the plain SQL
*/
@Support
ResultQuery resultQuery(String sql, QueryPart... parts);
// -------------------------------------------------------------------------
// XXX JDBC convenience methods
// -------------------------------------------------------------------------
/**
* Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ
* {@link Result}.
*
* After fetching all data, the JDBC ResultSet will be closed.
*
* Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a
* time, instead of load the entire ResultSet into a jOOQ
* Result at once.
*
* @param rs The JDBC ResultSet to fetch data from
* @return The resulting jOOQ Result
* @throws DataAccessException if something went wrong executing the query
*/
@Support
Result fetch(ResultSet rs) throws DataAccessException;
/**
* Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ
* {@link Result}.
*
* After fetching all data, the JDBC ResultSet will be closed.
*
* Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a
* time, instead of load the entire ResultSet into a jOOQ
* Result at once.
*
* The additional fields argument is used by jOOQ to coerce
* field names and data types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param fields The fields to use in the desired output
* @return The resulting jOOQ Result
* @throws DataAccessException if something went wrong executing the query
*/
@Support
Result fetch(ResultSet rs, Field... fields) throws DataAccessException;
/**
* Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ
* {@link Result}.
*
* After fetching all data, the JDBC ResultSet will be closed.
*
* Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a
* time, instead of load the entire ResultSet into a jOOQ
* Result at once.
*
* The additional types argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param types The data types to use in the desired output
* @return The resulting jOOQ Result
* @throws DataAccessException if something went wrong executing the query
*/
@Support
Result fetch(ResultSet rs, DataType... types) throws DataAccessException;
/**
* Fetch all data from a JDBC {@link ResultSet} and transform it to a jOOQ
* {@link Result}.
*
* After fetching all data, the JDBC ResultSet will be closed.
*
* Use {@link #fetchLazy(ResultSet)}, to fetch one Record at a
* time, instead of load the entire ResultSet into a jOOQ
* Result at once.
*
* The additional types argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param types The data types to use in the desired output
* @return The resulting jOOQ Result
* @throws DataAccessException if something went wrong executing the query
*/
@Support
Result fetch(ResultSet rs, Class... types) throws DataAccessException;
/**
* Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ
* {@link Record}.
*
* This will internally fetch all records and throw an exception if there
* was more than one resulting record.
*
* @param rs The JDBC ResultSet to fetch data from
* @return The resulting jOOQ record
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
*/
@Support
Record fetchOne(ResultSet rs) throws DataAccessException, InvalidResultException;
/**
* Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ
* {@link Record}.
*
* This will internally fetch all records and throw an exception if there
* was more than one resulting record.
*
* The additional fields argument is used by jOOQ to coerce
* field names and data types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param fields The fields to use in the desired output
* @return The resulting jOOQ record
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
*/
@Support
Record fetchOne(ResultSet rs, Field... fields) throws DataAccessException, InvalidResultException;
/**
* Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ
* {@link Record}.
*
* This will internally fetch all records and throw an exception if there
* was more than one resulting record.
*
* The additional types argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param types The data types to use in the desired output
* @return The resulting jOOQ record
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
*/
@Support
Record fetchOne(ResultSet rs, DataType... types) throws DataAccessException, InvalidResultException;
/**
* Fetch a record from a JDBC {@link ResultSet} and transform it to a jOOQ
* {@link Record}.
*
* This will internally fetch all records and throw an exception if there
* was more than one resulting record.
*
* The additional types argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param types The data types to use in the desired output
* @return The resulting jOOQ record
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
*/
@Support
Record fetchOne(ResultSet rs, Class... types) throws DataAccessException, InvalidResultException;
/**
* Fetch a record from a JDBC {@link ResultSet} and return the only
* contained value.
*
* This will internally fetch all records and throw an exception if there
* was more than one resulting record.
*
* @param rs The JDBC ResultSet to fetch data from
* @return The resulting value
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
* or a record with more than one value.
*/
@Support
Object fetchValue(ResultSet rs) throws DataAccessException, InvalidResultException;
/**
* Fetch a record from a JDBC {@link ResultSet} and return the only
* contained value.
*
* This will internally fetch all records and throw an exception if there
* was more than one resulting record.
*
* The additional field argument is used by jOOQ to coerce
* field names and data types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param field The field to use in the desired output
* @return The resulting value
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
* or a record with more than one value.
*/
@Support
T fetchValue(ResultSet rs, Field field) throws DataAccessException, InvalidResultException;
/**
* Fetch a record from a JDBC {@link ResultSet} and return the only
* contained value.
*
* This will internally fetch all records and throw an exception if there
* was more than one resulting record.
*
* The additional type argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param type The data type to use in the desired output
* @return The resulting value
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
* or a record with more than one value.
*/
@Support
T fetchValue(ResultSet rs, DataType type) throws DataAccessException, InvalidResultException;
/**
* Fetch a record from a JDBC {@link ResultSet} and return the only
* contained value.
*
* This will internally fetch all records and throw an exception if there
* was more than one resulting record.
*
* The additional type argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param type The data types to use in the desired output
* @return The resulting value
* @throws DataAccessException if something went wrong executing the query
* @throws InvalidResultException if the query returned more than one record
* or a record with more than one value.
*/
@Support
T fetchValue(ResultSet rs, Class type) throws DataAccessException, InvalidResultException;
/**
* Fetch a result from a JDBC {@link ResultSet} and return the only
* contained column's values.
*
* @param rs The JDBC ResultSet to fetch data from
* @return The resulting values
* @throws DataAccessException if something went wrong executing the query
*/
@Support
List fetchValues(ResultSet rs) throws DataAccessException;
/**
* Fetch a result from a JDBC {@link ResultSet} and return the only
* contained column's values.
*
* The additional field argument is used by jOOQ to coerce
* field names and data types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param field The field to use in the desired output
* @return The resulting values
* @throws DataAccessException if something went wrong executing the query
*/
@Support
List fetchValues(ResultSet rs, Field field) throws DataAccessException;
/**
* Fetch a result from a JDBC {@link ResultSet} and return the only
* contained column's values.
*
* The additional type argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param type The data type to use in the desired output
* @return The resulting values
* @throws DataAccessException if something went wrong executing the query
*/
@Support
List fetchValues(ResultSet rs, DataType type) throws DataAccessException;
/**
* Fetch a result from a JDBC {@link ResultSet} and return the only
* contained column's values.
*
* The additional type argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param type The data types to use in the desired output
* @return The resulting values
* @throws DataAccessException if something went wrong executing the query
*/
@Support
List fetchValues(ResultSet rs, Class type) throws DataAccessException;
/**
* Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}.
*
* Use {@link #fetch(ResultSet)}, to load the entire ResultSet
* into a jOOQ Result at once.
*
* @param rs The JDBC ResultSet to fetch data from
* @return The resulting jOOQ Result
* @throws DataAccessException if something went wrong executing the query
*/
@Support
Cursor fetchLazy(ResultSet rs) throws DataAccessException;
/**
* Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}.
*
* Use {@link #fetch(ResultSet)}, to load the entire ResultSet
* into a jOOQ Result at once.
*
* The additional fields argument is used by jOOQ to coerce
* field names and data types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param fields The fields to use in the desired output
* @return The resulting jOOQ Result
* @throws DataAccessException if something went wrong executing the query
*/
@Support
Cursor fetchLazy(ResultSet rs, Field... fields) throws DataAccessException;
/**
* Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}.
*
* Use {@link #fetch(ResultSet)}, to load the entire ResultSet
* into a jOOQ Result at once.
*
* The additional types argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param types The data types to use in the desired output
* @return The resulting jOOQ Result
* @throws DataAccessException if something went wrong executing the query
*/
@Support
Cursor fetchLazy(ResultSet rs, DataType... types) throws DataAccessException;
/**
* Wrap a JDBC {@link ResultSet} into a jOOQ {@link Cursor}.
*
* Use {@link #fetch(ResultSet)}, to load the entire ResultSet
* into a jOOQ Result at once.
*
* The additional types argument is used by jOOQ to coerce data
* types to the desired output
*
* @param rs The JDBC ResultSet to fetch data from
* @param types The data types to use in the desired output
* @return The resulting jOOQ Result
* @throws DataAccessException if something went wrong executing the query
*/
@Support
Cursor fetchLazy(ResultSet rs, Class... types) throws DataAccessException;
/**
* Fetch all data from a formatted string.
*
* The supplied string is supposed to be formatted in a human-readable way.
* This is the same as calling fetchFromTXT(string, "{null}")
*
* @param string The formatted string
* @return The transformed result
* @see #fetchFromTXT(String, String)
* @throws DataAccessException If the supplied string does not adhere to the
* above format rules.
*/
@Support
Result fetchFromTXT(String string) throws DataAccessException;
/**
* Fetch all data from a formatted string.
*
* This method supports parsing results from two types of human-readable
* formats:
*
The jOOQ {@link Result#format()}
*
* This format is recognised by the fact that the first line starts with a
* "plus" sign:
* +-----+-----+--------------------------+
* |COL1 |COL2 |COL3 containing whitespace|
* +-----+-----+--------------------------+
* |val1 |1 |some text |
* |val2 | 2 | more text |
* +-----+-----+--------------------------+
*
* - The number of columns is defined by the number of dash groups in the
* first line. Groups are separated by exactly one "plus" sign
* - The column types are
VARCHAR(N) where
* N = number of dashes per dash group
* - The column names are defined by the trimmed text contained in the
* second row
* - The data is defined by the trimmed text contained in the subsequent
* rows
*
* The H2 database test data format
*
* The supplied string is supposed to be formatted in the following,
* human-readable way:
* COL1 COL2 COL3 containing whitespace
* ----- ---- --------------------------
* val1 1 some text
* val2 2 more text
*
* - The number of columns is defined by the number of dash groups in the
* second line. Groups are separated by space(s)
* - The column types are
VARCHAR(N) where
* N = number of dashes per dash group
* - The column names are defined by the trimmed text contained in the
* first row
* - The data is defined by the trimmed text contained in the subsequent
* rows
*
* Both parsing methods
*
* Both parsing methods make no assumption about the resulting data types.
* Instead, all data is string-based.
*
* @param string The formatted string
* @param nullLiteral The string literal to be used as null
* value.
* @return The transformed result
* @throws DataAccessException If the supplied string does not adhere to the
* above format rules.
*/
@Support
Result fetchFromTXT(String string, String nullLiteral) throws DataAccessException;
/**
* Fetch all data from a CSV string.
*
* This is the same as calling fetchFromCSV(string, ',') and
* the inverse of calling {@link Result#formatCSV()}. The first row of the
* CSV data is required to hold field name information. Subsequent rows may
* contain data, which is interpreted as {@link String}. Use the various
* conversion methods to retrieve other data types from the
* Result:
*
* - {@link Result#getValues(Field, Class)}
* - {@link Result#getValues(int, Class)}
* - {@link Result#getValues(String, Class)}
* - {@link Result#getValues(Field, Converter)}
* - {@link Result#getValues(int, Converter)}
* - {@link Result#getValues(String, Converter)}
*
*
* Missing values result in null. Empty values result in empty
* Strings
*
* @param string The CSV string
* @return The transformed result
* @throws DataAccessException If anything went wrong parsing the CSV file
* @see #fetchFromCSV(String, char)
*/
@Support
Result fetchFromCSV(String string) throws DataAccessException;
/**
* Fetch all data from a CSV string.
*
* This is inverse of calling {@link Result#formatCSV(char)}. The first row
* of the CSV data is required to hold field name information. Subsequent
* rows may contain data, which is interpreted as {@link String}. Use the
* various conversion methods to retrieve other data types from the
* Result:
*
* - {@link Result#getValues(Field, Class)}
* - {@link Result#getValues(int, Class)}
* - {@link Result#getValues(String, Class)}
* - {@link Result#getValues(Field, Converter)}
* - {@link Result#getValues(int, Converter)}
* - {@link Result#getValues(String, Converter)}
*
*
* Missing values result in null. Empty values result in empty
* Strings
*
* @param string The CSV string
* @param delimiter The delimiter to expect between records
* @return The transformed result
* @throws DataAccessException If anything went wrong parsing the CSV file
* @see #fetchFromCSV(String)
* @see #fetchFromStringData(List)
*/
@Support
Result fetchFromCSV(String string, char delimiter) throws DataAccessException;
/**
* Fetch all data from a JSON string.
*
* This is the inverse of calling {@link Result#formatJSON()}. Use the
* various conversion methods to retrieve other data types from the
* Result:
*
* - {@link Result#getValues(Field, Class)}
* - {@link Result#getValues(int, Class)}
* - {@link Result#getValues(String, Class)}
* - {@link Result#getValues(Field, Converter)}
* - {@link Result#getValues(int, Converter)}
* - {@link Result#getValues(String, Converter)}
*
*
* Missing values result in null. Empty values result in empty
* Strings
*
* @param string The JSON string
* @return The transformed result
* @throws DataAccessException If anything went wrong parsing the JSON file
*/
@Support
Result fetchFromJSON(String string);
/**
* Fetch all data from a list of strings.
*
* This is used by methods such as
*
* - {@link #fetchFromCSV(String)}
* - {@link #fetchFromTXT(String)}
*
* The first element of the argument list should contain column names.
* Subsequent elements contain actual data. The degree of all arrays
* contained in the argument should be the same, although this is not a
* requirement. jOOQ will ignore excess data, and fill missing data with
* null.
*
* @param data The data to be transformed into a Result
* @return The transformed result
* @see #fetchFromStringData(List)
*/
Result fetchFromStringData(String[]... data);
/**
* Fetch all data from a list of strings.
*
* This is used by methods such as
*
* - {@link #fetchFromCSV(String)}
* - {@link #fetchFromTXT(String)}
*
* The first element of the argument list should contain column names.
* Subsequent elements contain actual data. The degree of all arrays
* contained in the argument should be the same, although this is not a
* requirement. jOOQ will ignore excess data, and fill missing data with
* null.
*
* @param data The data to be transformed into a Result
* @return The transformed result
*/
Result fetchFromStringData(List data);
// -------------------------------------------------------------------------
// XXX Global Query factory
// -------------------------------------------------------------------------
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(String)} for strictly non-recursive CTE
* and {@link #withRecursive(String)} for strictly
* recursive CTE.
*/
@Support({ FIREBIRD, HSQLDB, POSTGRES })
WithAsStep with(String alias);
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(String, String...)} for strictly non-recursive CTE
* and {@link #withRecursive(String, String...)} for strictly
* recursive CTE.
*/
@Support({ FIREBIRD, HSQLDB, POSTGRES })
WithAsStep with(String alias, String... fieldAliases);
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* Reusable {@link CommonTableExpression} types can be constructed through
*
* - {@link DSL#name(String...)}
* - {@link Name#fields(String...)}
* -
* {@link DerivedColumnList#as(Select)}
*
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(CommonTableExpression...)} for strictly non-recursive CTE
* and {@link #withRecursive(CommonTableExpression...)} for strictly
* recursive CTE.
*/
@Support({ FIREBIRD, HSQLDB, POSTGRES })
WithStep with(CommonTableExpression... tables);
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(String)} for strictly non-recursive CTE
* and {@link #withRecursive(String)} for strictly
* recursive CTE.
*
* Note that the {@link SQLDialect#H2} database only supports single-table,
* RECURSIVE common table expression lists.
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
WithAsStep withRecursive(String alias);
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(String, String...)} for strictly non-recursive CTE
* and {@link #withRecursive(String, String...)} for strictly
* recursive CTE.
*
* Note that the {@link SQLDialect#H2} database only supports single-table,
* RECURSIVE common table expression lists.
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
WithAsStep withRecursive(String alias, String... fieldAliases);
/**
* Create a WITH clause to supply subsequent
* SELECT, UPDATE, INSERT,
* DELETE, and MERGE statements with
* {@link CommonTableExpression}s.
*
* Reusable {@link CommonTableExpression} types can be constructed through
*
* - {@link DSL#name(String...)}
* - {@link Name#fields(String...)}
* -
* {@link DerivedColumnList#as(Select)}
*
*
* The RECURSIVE keyword may be optional or unsupported in some
* databases, in case of which it will not be rendered. For optimal database
* interoperability and readability, however, it is suggested that you use
* {@link #with(CommonTableExpression...)} for strictly non-recursive CTE
* and {@link #withRecursive(CommonTableExpression...)} for strictly
* recursive CTE.
*
* Note that the {@link SQLDialect#H2} database only supports single-table,
* RECURSIVE common table expression lists.
*/
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
WithStep withRecursive(CommonTableExpression... tables);
/**
* Create a new DSL select statement.
*
* Example:
* SELECT * FROM [table] WHERE [conditions] ORDER BY [ordering] LIMIT [limit clause]
*
* 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);
*
* 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();
*
* 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)
* .select(field1)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, field4)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, field4, field5)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field5, field6)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field6, field7)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field7, field8)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field8, field9)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field9, field10)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field10, field11)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field11, field12)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field12, field13)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field13, field14)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
* 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)
* .select(field1, field2, field3, .., field14, field15)
* .from(table1)
* .join(table2).on(field1.equal(field2))
* .where(field1.greaterThan(100))
* .orderBy(field2);
*
