Overview  Package  Class   Use  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    

Uses of Class
org.jooq.exception.DataAccessException

Packages that use DataAccessException
org.jooq   
org.jooq.exception   
org.jooq.impl   
 

Uses of DataAccessException in org.jooq
 

Methods in org.jooq that return DataAccessException
 DataAccessException LoaderError.exception()
          The underlying DataAccessException that caused the error
 

Methods in org.jooq that throw DataAccessException
 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 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>
T
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>>
int
FactoryOperations.executeDelete(R record)
          Delete a record from a table DELETE FROM [table] WHERE [record is supplied record]
<R extends TableRecord<R>,T>
int
FactoryOperations.executeDelete(R record, Condition condition)
          Delete a record from a table DELETE FROM [table] WHERE [condition]
<R extends TableRecord<R>>
int
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>
int
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>>
int
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>
int
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>>
int
FactoryOperations.executeInsert(R record)
          Insert one record This executes something like the following statement: INSERT INTO [table] ...
<R extends TableRecord<R>>
int
FactoryOperations.executeInsert(Table<R> table, R record)
          Deprecated. - 2.5.0 [#1692] - Use FactoryOperations.executeInsert(TableRecord) instead
<R extends UpdatableRecord<R>>
int
FactoryOperations.executeUpdate(R record)
          Update a table UPDATE [table] SET [modified values in record] WHERE [record is supplied record]
<R extends TableRecord<R>,T>
int
FactoryOperations.executeUpdate(R record, Condition condition)
          Update a table UPDATE [table] SET [modified values in record] WHERE [condition]
<R extends TableRecord<R>>
int
FactoryOperations.executeUpdate(Table<R> table, R record)
          Deprecated. - 2.5.0 [#1692] - This "mass" update is no longer supported
<R extends TableRecord<R>,T>
int
FactoryOperations.executeUpdate(Table<R> table, R record, Condition condition)
          Deprecated. - 2.5.0 [#1692] - Use FactoryOperations.executeUpdate(TableRecord, Condition) instead
<R extends TableRecord<R>>
int
FactoryOperations.executeUpdateOne(Table<R> table, R record)
          Deprecated. - 2.5.0 [#1692] - This "mass" update is no longer supported
<R extends TableRecord<R>,T>
int
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.
 Result<Record> FactoryOperations.fetch(ResultSet rs)
          Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
 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>
Result<R>
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>
Result<R>
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>
R
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.
<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,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>>
H
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>>
H
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>
Result<Z>
ResultQuery.fetchInto(Table<Z> table)
          Map resulting records onto a custom record.
<Z extends Record>
Result<Z>
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)
          Fetch all data from a JDBC ResultSet and transform it to a jOOQ Result.
 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.
<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,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.
 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>
R
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>
R
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>>
H
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>
Z
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()
          Execute the query and return the generated result as a JDBC ResultSet This will return the ResultSet returned by the JDBC driver, leaving it untouched.
 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>
T
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.
 

Uses of DataAccessException in org.jooq.exception
 

Subclasses of DataAccessException in org.jooq.exception
 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
          An operation was invoked on a detached object (Query, QueryPart, or UpdatableRecord).
 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)
 

Uses of DataAccessException in org.jooq.impl
 

Methods in org.jooq.impl that throw DataAccessException
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>
int
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.
 

Overview  Package  Class   Use  Deprecated  Index  Help 
 PREV   NEXT FRAMES    NO FRAMES    
Copyright © 2012. All Rights Reserved.