Package | Description |
---|---|
org.jooq |
The
org.jooq package contains jOOQ's public API
This package mostly contains interfaces that are implemented by the
org.jooq.impl package. |
org.jooq.exception |
The
org.jooq.exception package contains jOOQ's exceptions |
org.jooq.impl |
The
org.jooq.impl package contains jOOQ's implementation classes
This package provides implementations for the jOOQ API from
org.jooq , whose interfaces are constructed mostly through the
Factory class, which hides implementation facts from
the public API |
Modifier and Type | Method and Description |
---|---|
DataAccessException |
LoaderError.exception()
The underlying
DataAccessException that caused the error |
Modifier and Type | Method and Description |
---|---|
void |
SelectQuery.addJoinOnKey(TableLike<?> table,
JoinType type)
Joins the existing table product to a new table using a foreign key
|
void |
SelectQuery.addJoinOnKey(TableLike<?> table,
JoinType type,
TableField<?,?>... keyFields)
Joins the existing table product to a new table using a foreign key
|
void |
QueryPartInternal.bind(BindContext context)
Bind all parameters of this
QueryPart to a PreparedStatement
This method is for JOOQ INTERNAL USE only. |
BindContext |
BindContext.bind(Collection<? extends QueryPart> parts)
Bind values from several
QueryPart 's. |
BatchBindStep |
BatchBindStep.bind(Object... bindValues)
Set bind values on the batch statement
|
BindContext |
BindContext.bind(QueryPart part)
Bind values from a
QueryPart . |
BindContext |
BindContext.bind(QueryPart[] parts)
Bind values from several
QueryPart 's. |
BindContext |
BindContext.bindValue(Object value,
Class<?> type)
Bind a value using a specific type.
|
BindContext |
BindContext.bindValues(Object... values)
Bind several values.
|
void |
Query.cancel()
Cancel the underlying statement
This cancels the query's underlying
Statement or
PreparedStatement . |
void |
Query.close()
Close the underlying statement
This closes the query's underlying
Statement or
PreparedStatement if a previous call to
Query.keepStatement(boolean) indicated that jOOQ should keep
statements open after query execution. |
void |
Cursor.close()
Explicitly close the underlying
PreparedStatement and
ResultSet
If you fetch all records from the underlying ResultSet , jOOQ
Cursor implementations will close themselves for you. |
void |
FactoryOperations.commit()
Convenience method to access
Connection.commit()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
long |
DAO.count()
Count all records of the underlying table.
|
<T extends Number> |
FactoryOperations.currval(Sequence<T> sequence)
Convenience method to fetch the CURRVAL for a sequence directly from this
Factory 's underlying JDBC Connection |
int |
UpdatableRecord.delete()
Deletes this record from the database, based on the value of the primary
key or main unique key.
|
void |
DAO.delete(Collection<P> objects)
Performs a
DELETE statement for a given set of POJOs |
void |
DAO.delete(P... objects)
Performs a
DELETE statement for a given set of POJOs |
void |
DAO.deleteById(Collection<T> ids)
Performs a
DELETE statement for a given set of IDs |
void |
DAO.deleteById(T... ids)
Performs a
DELETE statement for a given set of IDs |
int |
TableRecord.deleteUsing(TableField<R,?>... keys)
Deprecated.
- 2.5.0 [#1736] - These methods will be made part of jOOQ's
internal API soon. Do not reuse these methods.
|
int |
Routine.execute()
Execute the stored object on an underlying connection
|
int |
Query.execute()
Execute the query, if it has been created with a properly configured
factory
|
int[] |
Batch.execute()
Execute the batch operation.
|
int |
Routine.execute(Configuration configuration)
Execute the stored object using a
Configuration object |
int |
FactoryOperations.execute(String sql)
Execute a query holding plain SQL.
|
int |
FactoryOperations.execute(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
int |
FactoryOperations.execute(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
<R extends UpdatableRecord<R>> |
FactoryOperations.executeDelete(R record)
Delete a record from a table
DELETE FROM [table] WHERE [record is supplied record] |
<R extends TableRecord<R>,T> |
FactoryOperations.executeDelete(R record,
Condition condition)
Delete a record from a table
DELETE FROM [table] WHERE [condition] |
<R extends TableRecord<R>> |
FactoryOperations.executeDelete(Table<R> table)
Deprecated.
- 2.5.0 [#1692] - The semantics of
FactoryOperations.executeDelete(TableRecord, Condition) has changed.
This method here is no longer necessary. |
<R extends TableRecord<R>,T> |
FactoryOperations.executeDelete(Table<R> table,
Condition condition)
Deprecated.
- 2.5.0 [#1692] - The semantics of
FactoryOperations.executeDelete(TableRecord, Condition) has changed.
This method here is no longer necessary. |
<R extends TableRecord<R>> |
FactoryOperations.executeDeleteOne(Table<R> table)
Deprecated.
- 2.5.0 [#1692] - The semantics of
FactoryOperations.executeDelete(TableRecord, Condition) has changed.
This method here is no longer necessary. |
<R extends TableRecord<R>,T> |
FactoryOperations.executeDeleteOne(Table<R> table,
Condition condition)
Deprecated.
- 2.5.0 [#1692] - The semantics of
FactoryOperations.executeDelete(TableRecord, Condition) has changed.
This method here is no longer necessary. |
<R extends TableRecord<R>> |
FactoryOperations.executeInsert(R record)
Insert one record
This executes something like the following statement:
INSERT INTO [table] ... |
<R extends TableRecord<R>> |
FactoryOperations.executeInsert(Table<R> table,
R record)
Deprecated.
- 2.5.0 [#1692] - Use
FactoryOperations.executeInsert(TableRecord)
instead |
<R extends UpdatableRecord<R>> |
FactoryOperations.executeUpdate(R record)
Update a table
UPDATE [table] SET [modified values in record] WHERE [record is supplied record] |
<R extends TableRecord<R>,T> |
FactoryOperations.executeUpdate(R record,
Condition condition)
Update a table
UPDATE [table] SET [modified values in record] WHERE [condition] |
<R extends TableRecord<R>> |
FactoryOperations.executeUpdate(Table<R> table,
R record)
Deprecated.
- 2.5.0 [#1692] - This "mass" update is no longer supported
|
<R extends TableRecord<R>,T> |
FactoryOperations.executeUpdate(Table<R> table,
R record,
Condition condition)
Deprecated.
- 2.5.0 [#1692] - Use
FactoryOperations.executeUpdate(TableRecord, Condition) instead |
<R extends TableRecord<R>> |
FactoryOperations.executeUpdateOne(Table<R> table,
R record)
Deprecated.
- 2.5.0 [#1692] - This "mass" update is no longer supported
|
<R extends TableRecord<R>,T> |
FactoryOperations.executeUpdateOne(Table<R> table,
R record,
Condition condition)
Deprecated.
- 2.5.0 [#1692] - The semantics of
FactoryOperations.executeUpdate(TableRecord, Condition) has changed.
This method here is no longer necessary. |
boolean |
DAO.exists(P object)
Checks if a given POJO exists
|
boolean |
DAO.existsById(T id)
Checks if a given ID exists
|
Result<R> |
ResultQuery.fetch()
Execute the query and return the generated result
This is the same as calling
Query.execute() and then
ResultQuery.getResult()
The result and its contained records are attached to the original
Configuration by default. |
Result<R> |
InsertResultStep.fetch()
The result holding returned values as specified by the
InsertReturningStep
This currently only works well for DB2, HSQLDB, MySQL, and Postgres |
Result<R> |
Cursor.fetch()
Fetch all remaining records as a result.
|
<T> List<T> |
ResultQuery.fetch(Field<?> field,
Class<? extends T> type)
Execute the query and return all values for a field from the generated
result.
|
<T> List<T> |
ResultQuery.fetch(Field<T> field)
Execute the query and return all values for a field from the generated
result.
|
<T,U> List<U> |
ResultQuery.fetch(Field<T> field,
Converter<? super T,U> converter)
Execute the query and return all values for a field from the generated
result.
|
<Z> List<P> |
DAO.fetch(Field<Z> field,
Z... values)
Find records by a given field and a set of values.
|
List<?> |
ResultQuery.fetch(int fieldIndex)
Execute the query and return all values for a field index from the
generated result.
|
Result<R> |
Cursor.fetch(int number)
Fetch the next couple of records from the cursor.
|
<T> List<T> |
ResultQuery.fetch(int fieldIndex,
Class<? extends T> type)
Execute the query and return all values for a field index from the
generated result.
|
<U> List<U> |
ResultQuery.fetch(int fieldIndex,
Converter<?,U> converter)
Execute the query and return all values for a field index from the
generated result.
|
<E> List<E> |
ResultQuery.fetch(RecordMapper<? super R,E> mapper)
Fetch results into a custom mapper callback
|
<E> List<E> |
Cursor.fetch(RecordMapper<? super R,E> mapper)
Fetch results into a custom mapper callback
|
Result<Record> |
FactoryOperations.fetch(ResultSet rs)
|
List<?> |
ResultQuery.fetch(String fieldName)
Execute the query and return all values for a field name from the
generated result.
|
Result<Record> |
FactoryOperations.fetch(String sql)
Execute a new query holding plain SQL.
|
<T> List<T> |
ResultQuery.fetch(String fieldName,
Class<? extends T> type)
Execute the query and return all values for a field name from the
generated result.
|
<U> List<U> |
ResultQuery.fetch(String fieldName,
Converter<?,U> converter)
Execute the query and return all values for a field name from the
generated result.
|
Result<Record> |
FactoryOperations.fetch(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
Result<Record> |
FactoryOperations.fetch(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
<R extends Record> |
FactoryOperations.fetch(Table<R> table)
Execute and return all records for
SELECT * FROM [table]
The result and its contained records are attached to this
Configuration by default. |
<R extends Record> |
FactoryOperations.fetch(Table<R> table,
Condition condition)
Execute and return all records for
SELECT * FROM [table] WHERE [condition]
The result and its contained records are attached to this
Configuration by default. |
R |
ResultQuery.fetchAny()
Execute the query and return at most one resulting record.
|
<R extends Record> |
FactoryOperations.fetchAny(Table<R> table)
Execute and return zero or one record for
SELECT * FROM [table] LIMIT 1
The resulting record is attached to this Configuration by
default. |
<T> T[] |
ResultQuery.fetchArray(Field<?> field,
Class<? extends T> type)
Execute the query and return all values for a field from the generated
result.
|
<T> T[] |
ResultQuery.fetchArray(Field<T> field)
Execute the query and return all values for a field from the generated
result.
|
<T,U> U[] |
ResultQuery.fetchArray(Field<T> field,
Converter<? super T,U> converter)
Execute the query and return all values for a field from the generated
result.
|
Object[] |
ResultQuery.fetchArray(int fieldIndex)
Execute the query and return all values for a field index from the
generated result.
|
<T> T[] |
ResultQuery.fetchArray(int fieldIndex,
Class<? extends T> type)
Execute the query and return all values for a field index from the
generated result.
|
<U> U[] |
ResultQuery.fetchArray(int fieldIndex,
Converter<?,U> converter)
Execute the query and return all values for a field index from the
generated result.
|
Object[] |
ResultQuery.fetchArray(String fieldName)
Execute the query and return all values for a field name from the
generated result.
|
<T> T[] |
ResultQuery.fetchArray(String fieldName,
Class<? extends T> type)
Execute the query and return all values for a field name from the
generated result.
|
<U> U[] |
ResultQuery.fetchArray(String fieldName,
Converter<?,U> converter)
Execute the query and return all values for a field name from the
generated result.
|
Object[][] |
ResultQuery.fetchArrays()
Execute the query and return the generated result as an Object matrix
You can access data like this
query.fetchArray()[recordIndex][fieldIndex] |
Result<Record> |
FactoryOperations.fetchFromCSV(String string)
Fetch all data from a CSV string.
|
Result<Record> |
FactoryOperations.fetchFromCSV(String string,
char delimiter)
Fetch all data from a CSV string.
|
Map<Record,Result<R>> |
ResultQuery.fetchGroups(Field<?>[] keys)
Execute the query and return a
Map with the result grouped by the
given keys. |
<K> Map<K,Result<R>> |
ResultQuery.fetchGroups(Field<K> key)
Execute the query and return a
Map with one of the result's
columns as key and a list of corresponding records as value. |
<K,E> Map<K,List<E>> |
ResultQuery.fetchGroups(Field<K> key,
Class<? extends E> type)
Return a
Map with results grouped by the given key and mapped
into the given entity type. |
<K,V> Map<K,List<V>> |
ResultQuery.fetchGroups(Field<K> key,
Field<V> value)
Execute the query and return a
Map with one of the result's
columns as key and another one of the result's columns as value
Unlike ResultQuery.fetchMap(Field, Field) , this method allows for non-unique
keys in the result set. |
<E> List<E> |
ResultQuery.fetchInto(Class<? extends E> type)
Map resulting records onto a custom type.
|
<E> List<E> |
Cursor.fetchInto(Class<? extends E> type)
Map resulting records onto a custom type.
|
<H extends RecordHandler<R>> |
ResultQuery.fetchInto(H handler)
Fetch results into a custom handler callback
The resulting records are attached to the original
Configuration
by default. |
<H extends RecordHandler<R>> |
Cursor.fetchInto(H handler)
Fetch results into a custom handler callback
The resulting records are attached to the original
Configuration
by default. |
<Z extends Record> |
ResultQuery.fetchInto(Table<Z> table)
Map resulting records onto a custom record.
|
<Z extends Record> |
Cursor.fetchInto(Table<Z> table)
Map resulting records onto a custom record.
|
FutureResult<R> |
ResultQuery.fetchLater()
Fetch results asynchronously.
|
FutureResult<R> |
ResultQuery.fetchLater(ExecutorService executor)
Fetch results asynchronously.
|
Cursor<R> |
ResultQuery.fetchLazy()
Execute the query and "lazily" return the generated result
The returned
Cursor holds a reference to the executed
PreparedStatement and the associated ResultSet . |
Cursor<R> |
ResultQuery.fetchLazy(int fetchSize)
Execute the query and "lazily" return the generated result
The returned
Cursor holds a reference to the executed
PreparedStatement and the associated ResultSet . |
Cursor<Record> |
FactoryOperations.fetchLazy(ResultSet rs)
|
Cursor<Record> |
FactoryOperations.fetchLazy(String sql)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
Cursor<Record> |
FactoryOperations.fetchLazy(String sql,
Object... bindings)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
Cursor<Record> |
FactoryOperations.fetchLazy(String sql,
QueryPart... parts)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
List<Result<Record>> |
ResultQuery.fetchMany()
Execute a query, possibly returning several result sets.
|
List<Result<Record>> |
FactoryOperations.fetchMany(String sql)
Execute a new query holding plain SQL, possibly returning several result
sets
Example (Sybase ASE):
String sql = "sp_help 'my_table'";
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. |
List<Result<Record>> |
FactoryOperations.fetchMany(String sql,
Object... bindings)
Execute a new query holding plain SQL, possibly returning several result
sets.
|
List<Result<Record>> |
FactoryOperations.fetchMany(String sql,
QueryPart... parts)
Execute a new query holding plain SQL, possibly returning several result
sets.
|
Map<Record,R> |
ResultQuery.fetchMap(Field<?>[] keys)
Execute the query and return a
Map with keys as a map key and the
corresponding record as value. |
<K> Map<K,R> |
ResultQuery.fetchMap(Field<K> key)
Execute the query and return a
Map with one of the result's
columns as key and the corresponding records as value. |
<K,E> Map<K,E> |
ResultQuery.fetchMap(Field<K> key,
Class<? extends E> type)
Execute the query and return a
Map with results grouped by the
given key and mapped into the given entity type. |
<K,V> Map<K,V> |
ResultQuery.fetchMap(Field<K> key,
Field<V> value)
Execute the query and return a
Map with one of the result's
columns as key and another one of the result's columns as value
An exception is thrown, if the key turns out to be non-unique in the
result set. |
List<Map<String,Object>> |
ResultQuery.fetchMaps()
Execute the query and return the generated result as a list of name/value
maps.
|
R |
ResultQuery.fetchOne()
Execute the query and return at most one resulting record.
|
R |
InsertResultStep.fetchOne()
The record holding returned values as specified by the
InsertReturningStep |
R |
Cursor.fetchOne()
Fetch the next record from the cursor
This will conveniently close the
Cursor , after the last
Record was fetched. |
<T> T |
ResultQuery.fetchOne(Field<?> field,
Class<? extends T> type)
Execute the query and return return at most one resulting value for a
field from the generated result.
|
<T> T |
ResultQuery.fetchOne(Field<T> field)
Execute the query and return return at most one resulting value for a
field from the generated result.
|
<T,U> U |
ResultQuery.fetchOne(Field<T> field,
Converter<? super T,U> converter)
Execute the query and return return at most one resulting value for a
field from the generated result.
|
<Z> P |
DAO.fetchOne(Field<Z> field,
Z value)
Find a unique record by a given field and a value.
|
Object |
ResultQuery.fetchOne(int fieldIndex)
Execute the query and return return at most one resulting value for a
field index from the generated result.
|
<T> T |
ResultQuery.fetchOne(int fieldIndex,
Class<? extends T> type)
Execute the query and return return at most one resulting value for a
field index from the generated result.
|
<U> U |
ResultQuery.fetchOne(int fieldIndex,
Converter<?,U> converter)
Execute the query and return return at most one resulting value for a
field index from the generated result.
|
<E> E |
Cursor.fetchOne(RecordMapper<? super R,E> mapper)
Fetch the next record into a custom mapper callback
This will conveniently close the
Cursor , after the last
Record was fetched. |
Object |
ResultQuery.fetchOne(String fieldName)
Execute the query and return return at most one resulting value for a
field name from the generated result.
|
Record |
FactoryOperations.fetchOne(String sql)
Execute a new query holding plain SQL.
|
<T> T |
ResultQuery.fetchOne(String fieldName,
Class<? extends T> type)
Execute the query and return return at most one resulting value for a
field name from the generated result.
|
<U> U |
ResultQuery.fetchOne(String fieldName,
Converter<?,U> converter)
Execute the query and return return at most one resulting value for a
field name from the generated result.
|
Record |
FactoryOperations.fetchOne(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
Record |
FactoryOperations.fetchOne(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
<R extends Record> |
FactoryOperations.fetchOne(Table<R> table)
Execute and return zero or one record for
SELECT * FROM [table]
The resulting record is attached to this Configuration by
default. |
<R extends Record> |
FactoryOperations.fetchOne(Table<R> table,
Condition condition)
Execute and return zero or one record for
SELECT * FROM [table] WHERE [condition]
The resulting record is attached to this Configuration by
default. |
Object[] |
ResultQuery.fetchOneArray()
Execute the query and return at most one resulting record as an array
You can access data like this
query.fetchOneArray()[fieldIndex] |
<E> E |
Cursor.fetchOneInto(Class<? extends E> type)
Map the next resulting record onto a custom type.
|
<H extends RecordHandler<R>> |
Cursor.fetchOneInto(H handler)
Fetch the next record into a custom handler callback
This will conveniently close the
Cursor , after the last
Record was fetched. |
<Z extends Record> |
Cursor.fetchOneInto(Table<Z> table)
Map the next resulting record onto a custom record.
|
Map<String,Object> |
ResultQuery.fetchOneMap()
Execute the query and return at most one resulting record as a name/value
map.
|
ResultSet |
ResultQuery.fetchResultSet()
|
List<P> |
DAO.findAll()
Find all records of the underlying table.
|
P |
DAO.findById(T id)
Find a record of the underlying table by ID.
|
boolean |
FactoryOperations.getAutoCommit()
Convenience method to access
Connection.getAutoCommit()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
int |
FactoryOperations.getHoldability()
Convenience method to access
Connection.getHoldability()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
int |
FactoryOperations.getTransactionIsolation()
Convenience method to access
Connection.getTransactionIsolation()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
boolean |
Cursor.hasNext()
Check whether this cursor has a next record
This will conveniently close the
Cursor , after the last
Record was fetched. |
void |
DAO.insert(Collection<P> objects)
Performs a batch
INSERT statement for a given set of POJOs |
void |
DAO.insert(P... objects)
Performs a batch
INSERT statement for a given set of POJOs |
void |
DAO.insert(P object)
Performs an
INSERT statement for a given POJO |
BigInteger |
FactoryOperations.lastID()
Retrieve the last inserted ID.
|
<T extends Number> |
FactoryOperations.nextval(Sequence<T> sequence)
Convenience method to fetch the NEXTVAL for a sequence directly from this
Factory 's underlying JDBC Connection |
TableOnConditionStep |
TableOnStep.onKey()
Join the table on a non-ambiguous foreign key relationship between the
two joined tables.
|
SelectJoinStep |
SelectOnStep.onKey()
Join the previous table on a non-ambiguous foreign key relationship
between the two joined tables.
|
TableOnConditionStep |
TableOnStep.onKey(TableField<?,?>... keyFields)
Join the table on a non-ambiguous foreign key relationship between the
two joined tables.
|
SelectJoinStep |
SelectOnStep.onKey(TableField<?,?>... keyFields)
Join the previous table on a non-ambiguous foreign key relationship
between the two joined tables.
|
void |
UpdatableRecord.refresh()
Refresh this record from the database, based on the value of the primary
key or main unique key.
|
void |
TableRecord.refreshUsing(TableField<R,?>... keys)
Deprecated.
- 2.5.0 [#1736] - These methods will be made part of jOOQ's
internal API soon. Do not reuse these methods.
|
void |
FactoryOperations.releaseSavepoint(Savepoint savepoint)
Convenience method to access
Connection.releaseSavepoint(Savepoint)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
ResultQuery<Record> |
FactoryOperations.resultQuery(String sql)
Create a new query holding plain SQL.
|
void |
FactoryOperations.rollback()
Convenience method to access
Connection.rollback()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
FactoryOperations.rollback(Savepoint savepoint)
Convenience method to access
Connection.rollback(Savepoint)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
FactoryOperations.setAutoCommit(boolean autoCommit)
Convenience method to access
Connection.setAutoCommit(boolean)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
FactoryOperations.setHoldability(int holdability)
Convenience method to access
Connection.setHoldability(int)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
Savepoint |
FactoryOperations.setSavepoint()
Convenience method to access
Connection.setSavepoint()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
Savepoint |
FactoryOperations.setSavepoint(String name)
Convenience method to access
Connection.setSavepoint(String)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
FactoryOperations.setTransactionIsolation(int level)
Convenience method to access
Connection.setTransactionIsolation(int)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
int |
UpdatableRecord.store()
Store this record back to the database.
|
int |
TableRecord.storeUsing(TableField<R,?>... keys)
Deprecated.
- 2.5.0 [#1736] - These methods will be made part of jOOQ's
internal API soon. Do not reuse these methods.
|
void |
DAO.update(Collection<P> objects)
Performs a batch
UPDATE statement for a given set of POJOs |
void |
DAO.update(P... objects)
Performs a batch
UPDATE statement for a given set of POJOs |
void |
DAO.update(P object)
Performs an
UPDATE statement for a given POJO |
int |
FactoryOperations.use(Schema schema)
Use a schema as the default schema of the underlying connection.
|
int |
FactoryOperations.use(String schema)
Use a schema as the default schema of the underlying connection.
|
Modifier and Type | Class and Description |
---|---|
class |
DataChangedException
An error occurred while storing a record whose underlying data had already
been changed
|
class |
DataTypeException
An error occurred while handling data types.
|
class |
DetachedException
|
class |
InvalidResultException
An unexpected result was encountered after executing a
Query . |
class |
MappingException
An error occurred while fetching data into a user defined Java object with
any of these methods:
ResultQuery.fetchInto(Class)
Cursor.fetchInto(Class)
Result.into(Class)
Record.into(Class)
... or when copying data into a Record with any of these methods
FactoryOperations.newRecord(org.jooq.Table, Object)
Record.from(Object)
|
Modifier and Type | Method and Description |
---|---|
abstract void |
CustomField.bind(BindContext context)
Subclasses must implement this method
Bind all parameters of this QueryPart to a PreparedStatement
This method is for JOOQ INTERNAL USE only. |
abstract void |
CustomCondition.bind(BindContext context)
Subclasses must implement this method
Bind all parameters of this QueryPart to a PreparedStatement
This method is for JOOQ INTERNAL USE only. |
void |
Factory.commit()
Convenience method to access
Connection.commit()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
int |
Factory.execute(String sql)
Execute a query holding plain SQL.
|
int |
Factory.execute(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
int |
Factory.execute(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
<R extends TableRecord<R>,T> |
Factory.executeDelete(Table<R> table,
Condition condition)
Deprecated.
|
Result<Record> |
Factory.fetch(String sql)
Execute a new query holding plain SQL.
|
Result<Record> |
Factory.fetch(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
Result<Record> |
Factory.fetch(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
Cursor<Record> |
Factory.fetchLazy(String sql)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
Cursor<Record> |
Factory.fetchLazy(String sql,
Object... bindings)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
Cursor<Record> |
Factory.fetchLazy(String sql,
QueryPart... parts)
Execute a new query holding plain SQL and "lazily" return the generated
result.
|
List<Result<Record>> |
Factory.fetchMany(String sql)
Execute a new query holding plain SQL, possibly returning several result
sets
Example (Sybase ASE):
String sql = "sp_help 'my_table'";
NOTE: When inserting plain SQL into jOOQ objects, you must
guarantee syntax integrity. |
List<Result<Record>> |
Factory.fetchMany(String sql,
Object... bindings)
Execute a new query holding plain SQL, possibly returning several result
sets.
|
List<Result<Record>> |
Factory.fetchMany(String sql,
QueryPart... parts)
Execute a new query holding plain SQL, possibly returning several result
sets.
|
Record |
Factory.fetchOne(String sql)
Execute a new query holding plain SQL.
|
Record |
Factory.fetchOne(String sql,
Object... bindings)
Execute a new query holding plain SQL.
|
Record |
Factory.fetchOne(String sql,
QueryPart... parts)
Execute a new query holding plain SQL.
|
boolean |
Factory.getAutoCommit()
Convenience method to access
Connection.getAutoCommit()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
int |
Factory.getHoldability()
Convenience method to access
Connection.getHoldability()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
int |
Factory.getTransactionIsolation()
Convenience method to access
Connection.getTransactionIsolation()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
Factory.releaseSavepoint(Savepoint savepoint)
Convenience method to access
Connection.releaseSavepoint(Savepoint)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
Factory.rollback()
Convenience method to access
Connection.rollback()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
Factory.rollback(Savepoint savepoint)
Convenience method to access
Connection.rollback(Savepoint)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
Factory.setAutoCommit(boolean autoCommit)
Convenience method to access
Connection.setAutoCommit(boolean)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
Factory.setHoldability(int holdability)
Convenience method to access
Connection.setHoldability(int)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
Savepoint |
Factory.setSavepoint()
Convenience method to access
Connection.setSavepoint()
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
Savepoint |
Factory.setSavepoint(String name)
Convenience method to access
Connection.setSavepoint(String)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
void |
Factory.setTransactionIsolation(int level)
Convenience method to access
Connection.setTransactionIsolation(int)
Use this method only if you control the JDBC Connection wrapped
by this Configuration , and if that connection manages the current
transaction. |
Copyright © 2013. All Rights Reserved.