github/jooq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[#2187] Change all Javadoc <h3/> tags to <h5/>

Browse Source
This commit is contained in:
Lukas Eder 2013-02-13 17:47:01 +01:00
parent d6715ac5a2
commit 4d87dd6ee6
8 changed files with 131 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
jOOQ/src/main/java/org/jooq/ExecuteListener.java
View File

@ -240,7 +240,9 @@ import org.jooq.tools.StopWatchListener;
* </tr>
* </table>
* <br/>
* <h3>Legend:</h3>
* <p>
* <h5>Legend:</h5>
* <p>
* <ol>
* <li>Used with {@link ResultQuery} of statement type
* {@link StatementType#PREPARED_STATEMENT}</li>

99
jOOQ/src/main/java/org/jooq/Record.java
View File

@ -65,14 +65,14 @@ import org.jooq.tools.reflect.Reflect;
* implementations often specialise the above description in any of the
* following ways:
* <p>
* <h3>Table records</h3>
* <h5>Table records</h5>
* <p>
* Records originating from a concrete database table (or view) are modelled by
* jOOQ as {@link TableRecord} or {@link UpdatableRecord}, if they contain a
* primary key. If you're using jOOQ's code generator, you can generate even
* more concrete types of table records, i.e. one table record per table.
* <p>
* <h3>UDT records</h3>
* <h5>UDT records</h5>
* <p>
* {@link SQLDialect#ORACLE} and {@link SQLDialect#POSTGRES} formally support
* user defined types (UDT), which are modelled by jOOQ as {@link UDTRecord}. In
@ -80,7 +80,7 @@ import org.jooq.tools.reflect.Reflect;
* implement the JDBC {@link SQLData} API in order to be streamed to a JDBC
* {@link PreparedStatement} or from a JDBC {@link ResultSet}
* <p>
* <h3>Records of well-defined degree</h3>
* <h5>Records of well-defined degree</h5>
* <p>
* When projecting custom record types in SQL, new ad-hoc types of a certain
* degree are formed on the fly. Records with degree &lt= 22 are reflected by
@ -91,7 +91,7 @@ import org.jooq.tools.reflect.Reflect;
* Note that generated <code>TableRecords</code> and <code>UDTRecords</code>
* also implement a <code>Record[N]</code> interface, if <code>N &lt;= 22</code>
* <p>
* <h3>Record implements Comparable</h3>
* <h5>Record implements Comparable</h5>
* <p>
* jOOQ records have a natural ordering implemented in the same way as this is
* defined in the SQL standard. For more details, see the
@ -634,15 +634,18 @@ public interface Record extends Attachable, Comparable<Record> {
* Map resulting records onto a custom type.
* <p>
* The mapping algorithm is this:
* <h3>If <code>type</code> is an array:</h3> The resulting array is of the
* nature described in {@link #intoArray()}. Arrays more specific than
* <code>Object[]</code> can be specified as well, e.g.
* <code>String[]</code>. If conversion fails, a {@link MappingException} is
* thrown, wrapping conversion exceptions.
* <p>
* <h3>If a default constructor is available and any JPA {@link Column}
* <h5>If <code>type</code> is an array:</h5>
* <p>
* The resulting array is of the nature described in {@link #intoArray()}.
* Arrays more specific than <code>Object[]</code> can be specified as well,
* e.g. <code>String[]</code>. If conversion fails, a
* {@link MappingException} is thrown, wrapping conversion exceptions.
* <p>
* <h5>If a default constructor is available and any JPA {@link Column}
* annotations are found on the provided <code>type</code>, only those are
* used:</h3>
* used:</h5>
* <p>
* <ul>
* <li>If <code>type</code> contains public single-argument instance methods
* annotated with <code>Column</code>, those methods are invoked</li>
@ -661,12 +664,14 @@ public interface Record extends Attachable, Comparable<Record> {
* <li>Static methods / member fields are ignored</li>
* <li>Final member fields are ignored</li>
* </ul>
* <h3>If a default constructor is available and if there are no JPA
* <p>
* <h5>If a default constructor is available and if there are no JPA
* <code>Column</code> annotations, or jOOQ can't find the
* <code>javax.persistence</code> API on the classpath, jOOQ will map
* <code>Record</code> values by naming convention:</h3> If
* {@link Field#getName()} is <code>MY_field</code> (case-sensitive!), then
* this field's value will be set on all of these:
* <code>Record</code> values by naming convention:</h5>
* <p>
* If {@link Field#getName()} is <code>MY_field</code> (case-sensitive!),
* then this field's value will be set on all of these:
* <ul>
* <li>Public single-argument instance method <code>MY_field(...)</code></li>
* <li>Public single-argument instance method <code>myField(...)</code></li>
@ -675,9 +680,11 @@ public interface Record extends Attachable, Comparable<Record> {
* <li>Public non-final instance member field <code>MY_field</code></li>
* <li>Public non-final instance member field <code>myField</code></li>
* </ul>
* <h3>If no default constructor is available, but at least one constructor
* <p>
* <h5>If no default constructor is available, but at least one constructor
* annotated with <code>ConstructorProperties</code> is available, that one
* is used</h3>
* is used</h5>
* <p>
* <ul>
* <li>The standard JavaBeans {@link ConstructorProperties} annotation is
* used to match constructor arguments against POJO members or getters.</li>
@ -692,8 +699,10 @@ public interface Record extends Attachable, Comparable<Record> {
* <li>When invoking the annotated constructor, values are converted onto
* constructor argument types</li>
* </ul>
* <h3>If no default constructor is available, but at least one "matching"
* constructor is available, that one is used</h3>
* <p>
* <h5>If no default constructor is available, but at least one "matching"
* constructor is available, that one is used</h5>
* <p>
* <ul>
* <li>A "matching" constructor is one with exactly as many arguments as
* this record holds fields</li>
@ -702,13 +711,17 @@ public interface Record extends Attachable, Comparable<Record> {
* <li>When invoking the "matching" constructor, values are converted onto
* constructor argument types</li>
* </ul>
* <h3>If the supplied type is an interface or an abstract class</h3>
* <p>
* <h5>If the supplied type is an interface or an abstract class</h5>
* <p>
* Abstract types are instanciated using Java reflection {@link Proxy}
* mechanisms. The returned proxy will wrap a {@link HashMap} containing
* properties mapped by getters and setters of the supplied type. Methods
* (even JPA-annotated ones) other than standard POJO getters and setters
* are not supported. Details can be seen in {@link Reflect#as(Class)}.
* <h3>Other restrictions</h3>
* <p>
* <h5>Other restrictions</h5>
* <p>
* <ul>
* <li><code>type</code> must provide a default or a "matching" constructor.
* Non-public default constructors are made accessible using
@ -746,8 +759,8 @@ public interface Record extends Attachable, Comparable<Record> {
/**
* Map resulting records onto a custom record type.
* <p>
* The mapping algorithm is this:
* <h3>jOOQ will map <code>Record</code> values by equal field names:</h3>
* The mapping algorithm is this:<p>
* <h5>jOOQ will map <code>Record</code> values by equal field names:</h5><p>
* <ul>
* <li>For every field in the <code>table</code> argument with
* {@link Field#getName()} <code>"MY_field"</code> (case-sensitive!), a
@ -756,8 +769,8 @@ public interface Record extends Attachable, Comparable<Record> {
* {@link Field#getName()}, then the first one returning true on
* {@link Field#equals(Object)} will be returned. (e.g. qualified field
* names match)</li>
* </ul>
* <h3>Other restrictions</h3>
* </ul><p>
* <h5>Other restrictions</h5><p>
* <ul>
* <li>{@link Table#getRecordType()} must return a class of type
* {@link TableRecord}, which must provide a default constructor. Non-public
@ -811,16 +824,16 @@ public interface Record extends Attachable, Comparable<Record> {
<E> E map(RecordMapper<Record, E> mapper);
/**
* Load data into this record from a source. The mapping algorithm is this:
* <h3>If <code>source</code> is an <code>array</code></h3>
* Load data into this record from a source.<p>The mapping algorithm is this:<p>
* <h5>If <code>source</code> is an <code>array</code></h5>
* <p>
* Loading of data is delegated to {@link #fromArray(Object...)}
* <h3>If <code>source</code> is a {@link Map}</h3>
* Loading of data is delegated to {@link #fromArray(Object...)}<p>
* <h5>If <code>source</code> is a {@link Map}</h5><p>
* <p>
* Loading of data is delegated to {@link #fromMap(Map)}
* <h3>If any JPA {@link Column} annotations are found on the {@link Class}
* Loading of data is delegated to {@link #fromMap(Map)}<p>
* <h5>If any JPA {@link Column} annotations are found on the {@link Class}
* of the provided <code>source</code>, only those are used. Matching
* candidates are:</h3>
* candidates are:</h5><p>
* <ul>
* <li>Public no-argument instance methods annotated with
* <code>Column</code></li>
@ -839,10 +852,10 @@ public interface Record extends Attachable, Comparable<Record> {
* <li>Explicitly matching methods have a higher priority than implicitly
* matching methods (implicitly matching getter = setter is annotated)</li>
* <li>Static methods / member fields are ignored</li>
* </ul>
* <h3>If there are no JPA <code>Column</code> annotations, or jOOQ can't
* </ul><p>
* <h5>If there are no JPA <code>Column</code> annotations, or jOOQ can't
* find the <code>javax.persistence</code> API on the classpath, jOOQ will
* map members by naming convention:</h3> If {@link Field#getName()} is
* map members by naming convention:</h5><p> If {@link Field#getName()} is
* <code>MY_field</code> (case-sensitive!), then this field's value will be
* fetched from the first of these:
* <ul>
@ -852,12 +865,12 @@ public interface Record extends Attachable, Comparable<Record> {
* <li>Public no-argument instance method <code>getMyField()</code></li>
* <li>Public instance member field <code>MY_field</code></li>
* <li>Public instance member field <code>myField</code></li>
* </ul>
* <h3>Other restrictions</h3>
* </ul><p>
* <h5>Other restrictions</h5><p>
* <ul>
* <li>primitive types are supported.</li>
* </ul>
* <h3>General notes</h3> The resulting record will have its internal
* </ul><p>
* <h5>General notes</h5><p> The resulting record will have its internal
* "changed" flags set to true for all values. This means that
* {@link UpdatableRecord#store()} will perform an <code>INSERT</code>
* statement. If you wish to store the record using an <code>UPDATE</code>
@ -958,13 +971,13 @@ public interface Record extends Attachable, Comparable<Record> {
* jOOQ Records implement {@link Comparable} to allow for naturally ordering
* Records in a "SQL way", i.e. according to the following rules:
* <p>
* <h3>Records being compared must have the same ROW type</h3>
* <h5>Records being compared must have the same ROW type</h5>
* <p>
* Two Records are comparable if and only if they have the same
* <code>ROW</code> type, i.e. if their {@link Record#fieldsRow() fieldsRow()}
* methods return fields of the same type and degree.
* <code>ROW</code> type, i.e. if their {@link Record#fieldsRow()
* fieldsRow()} methods return fields of the same type and degree.
* <p>
* <h3>Comparison rules</h3>
* <h5>Comparison rules</h5>
* <p>
* Assume the following notations:
* <ul>

23
jOOQ/src/main/java/org/jooq/SelectQuery.java
View File

@ -502,8 +502,9 @@ public interface SelectQuery<R extends Record> extends Select<R>, ConditionProvi
/**
* Sets the "FOR UPDATE" flag onto the query
* <p>
* <h3>Native implementation</h3> This has been observed to be supported by
* any of these dialects:
* <h5>Native implementation</h5>
* <p>
* This has been observed to be supported by any of these dialects:
* <ul>
* <li><a href=
* "http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/index.jsp?topic=/com.ibm.db2.luw.sql.ref.doc/doc/r0000879.html"
@ -526,10 +527,13 @@ public interface SelectQuery<R extends Record> extends Select<R>, ConditionProvi
* "http://www.postgresql.org/docs/9.0/static/sql-select.html#SQL-FOR-UPDATE-SHARE"
* >Postgres FOR UPDATE / FOR SHARE</a></li>
* </ul>
* <h3>Simulation</h3> These dialects can simulate the
* <code>FOR UPDATE</code> clause using a cursor. The cursor is handled by
* the JDBC driver, at {@link PreparedStatement} construction time, when
* calling {@link Connection#prepareStatement(String, int, int)} with
* <p>
* <h5>Simulation</h5>
* <p>
* These dialects can simulate the <code>FOR UPDATE</code> clause using a
* cursor. The cursor is handled by the JDBC driver, at
* {@link PreparedStatement} construction time, when calling
* {@link Connection#prepareStatement(String, int, int)} with
* {@link ResultSet#CONCUR_UPDATABLE}. jOOQ handles simulation of a
* <code>FOR UPDATE</code> clause using <code>CONCUR_UPDATABLE</code> for
* these dialects:
@ -539,8 +543,11 @@ public interface SelectQuery<R extends Record> extends Select<R>, ConditionProvi
* </ul>
* <p>
* Note: This simulation may not be efficient for large result sets!
* <h3>Not supported</h3> These dialects are known not to support the
* <code>FOR UPDATE</code> clause in regular SQL:
* <p>
* <h5>Not supported</h5>
* <p>
* These dialects are known not to support the <code>FOR UPDATE</code>
* clause in regular SQL:
* <ul>
* <li> {@link SQLDialect#SQLITE}</li>
* </ul>

21
jOOQ/src/main/java/org/jooq/Table.java
View File

@ -99,12 +99,13 @@ public interface Table<R extends Record> extends TableLike<R> {
* on {@link Settings#getRenderNameStyle()}. By default, table aliases are
* quoted, and thus case-sensitive!
* <p>
* <h3>Derived column lists for table references</h3> Note, not all
* databases support derived column lists for their table aliases. On the
* other hand, some databases do support derived column lists, but only for
* derived tables. jOOQ will try to turn table references into derived
* tables to make this syntax work. In other words, the following statements
* are equivalent: <code><pre>
* <h5>Derived column lists for table references</h5>
* <p>
* Note, not all databases support derived column lists for their table
* aliases. On the other hand, some databases do support derived column
* lists, but only for derived tables. jOOQ will try to turn table
* references into derived tables to make this syntax work. In other words,
* the following statements are equivalent: <code><pre>
* -- Using derived column lists to rename columns (e.g. Postgres)
* SELECT t.a, t.b
* FROM my_table t(a, b)
@ -116,9 +117,11 @@ public interface Table<R extends Record> extends TableLike<R> {
* ) t(a, b)
* </pre></code>
* <p>
* <h3>Derived column lists for derived tables</h3> Other databases may not
* support derived column lists at all, but they do support common table
* expressions. The following statements are equivalent: <code><pre>
* <h5>Derived column lists for derived tables</h5>
* <p>
* Other databases may not support derived column lists at all, but they do
* support common table expressions. The following statements are
* equivalent: <code><pre>
* -- Using derived column lists to rename columns (e.g. Postgres)
* SELECT t.a, t.b
* FROM (

15
jOOQ/src/main/java/org/jooq/UpdatableRecord.java
View File

@ -104,7 +104,7 @@ public interface UpdatableRecord<R extends UpdatableRecord<R>> extends TableReco
* Depending on the state of the primary key's or main unique key's value,
* an {@link #insert()} or an {@link #update()} statement is executed.
* <p>
* <h3>Statement type</h3>
* <h5>Statement type</h5>
* <p>
* <ul>
* <li>If this record was created by client code, an <code>INSERT</code>
@ -124,7 +124,8 @@ public interface UpdatableRecord<R extends UpdatableRecord<R>> extends TableReco
* <code>DEFAULT</code> values to be applied by the underlying RDBMS. If no
* fields were modified, neither an <code>UPDATE</code> nor an
* <code>INSERT</code> will be executed.
* <h3>Automatic value generation</h3>
* <p>
* <h5>Automatic value generation</h5>
* <p>
* Use {@link #insert()} or {@link #update()} to explicitly force either
* statement type.
@ -156,7 +157,8 @@ public interface UpdatableRecord<R extends UpdatableRecord<R>> extends TableReco
* manually using the various {@link Executor#insertInto(Table)},
* {@link Executor#update(Table)} methods.</li>
* </ul>
* <h3>Optimistic locking</h3>
* <p>
* <h5>Optimistic locking</h5>
* <p>
* If an <code>UPDATE</code> statement is executed and
* {@link Settings#isExecuteWithOptimisticLocking()} is set to
@ -191,7 +193,8 @@ public interface UpdatableRecord<R extends UpdatableRecord<R>> extends TableReco
* <p>
* See {@link SelectQuery#setForUpdate(boolean)} for more details</li>
* </ul>
* <h3>Statement examples</h3>
* <p>
* <h5>Statement examples</h5>
* <p>
* Possible statements are
* <ul>
@ -251,7 +254,7 @@ public interface UpdatableRecord<R extends UpdatableRecord<R>> extends TableReco
* Deletes this record from the database, based on the value of the primary
* key or main unique key.
* <p>
* <h3>Optimistic locking</h3>
* <h5>Optimistic locking</h5>
* <p>
* If a <code>DELETE</code> statement is executed and
* {@link Settings#isExecuteWithOptimisticLocking()} is set to
@ -286,7 +289,7 @@ public interface UpdatableRecord<R extends UpdatableRecord<R>> extends TableReco
* <p>
* See {@link SelectQuery#setForUpdate(boolean)} for more details</li>
* </ul>
* <h3>Statement examples</h3>
* <h5>Statement examples</h5>
* <p>
* The executed statement is <code><pre>
* DELETE FROM [table]

4
jOOQ/src/main/java/org/jooq/impl/DefaultExecuteContext.java
View File

@ -100,7 +100,7 @@ class DefaultExecuteContext extends AbstractConfiguration implements ExecuteCont
/**
* Clean up blobs, clobs and the local configuration.
* <p>
* <h3>BLOBS and CLOBS</h3>
* <h5>BLOBS and CLOBS</h5>
* <p>
* [#1326] This is necessary in those dialects that have long-lived
* temporary lob objects, which can cause memory leaks in certain contexts,
@ -114,7 +114,7 @@ class DefaultExecuteContext extends AbstractConfiguration implements ExecuteCont
* {@link OutOfMemoryError}</li>
* </ol>
* <p>
* <h3>Local configuration</h3>
* <h5>Local configuration</h5>
* <p>
* [#1544] There exist some corner-cases regarding the {@link SQLOutput}
* API, used for UDT serialisation / deserialisation, which have no elegant

47
jOOQ/src/main/java/org/jooq/impl/Executor.java
View File

@ -4742,11 +4742,14 @@ public class Executor implements Configuration {
* batch mode (with bind values).
* <p>
* This batch operation can be executed in two modes:
* <h3>With
* <p>
* <h5>With
* <code>{@link Settings#getStatementType()} == {@link StatementType#PREPARED_STATEMENT}</code>
* (the default)</h3> In this mode, record order is preserved as much as
* possible, as long as two subsequent records generate the same SQL (with
* bind variables). The number of executed batch operations corresponds to
* (the default)</h5>
* <p>
* In this mode, record order is preserved as much as possible, as long as
* two subsequent records generate the same SQL (with bind variables). The
* number of executed batch operations corresponds to
* <code>[number of distinct rendered SQL statements]</code>. In the worst
* case, this corresponds to the number of total records.
* <p>
@ -4764,12 +4767,14 @@ public class Executor implements Configuration {
* <li>INSERT b1, b3</li>
* <li>INSERT c1</li>
* </ol>
* <h3>With
* <p>
* <h5>With
* <code>{@link Settings#getStatementType()} == {@link StatementType#STATIC_STATEMENT}</code>
* </h3> This mode may be better for large and complex batch store
* operations, as the order of records is preserved entirely, and jOOQ can
* guarantee that only a single batch statement is serialised to the
* database.
* </h5>
* <p>
* This mode may be better for large and complex batch store operations, as
* the order of records is preserved entirely, and jOOQ can guarantee that
* only a single batch statement is serialised to the database.
*
* @see Statement#executeBatch()
*/
@ -4837,16 +4842,20 @@ public class Executor implements Configuration {
public final Batch batchUpdate(Collection<? extends UpdatableRecord<?>> records) {
return batchUpdate(records.toArray(new UpdatableRecord[records.size()]));
}
/**
* Execute a set of <code>DELETE</code> queries in batch mode (with bind
* values).
* <p>
* This batch operation can be executed in two modes:
* <h3>With
* <p>
* <h5>With
* <code>{@link Settings#getStatementType()} == {@link StatementType#PREPARED_STATEMENT}</code>
* (the default)</h3> In this mode, record order is preserved as much as
* possible, as long as two subsequent records generate the same SQL (with
* bind variables). The number of executed batch operations corresponds to
* (the default)</h5>
* <p>
* In this mode, record order is preserved as much as possible, as long as
* two subsequent records generate the same SQL (with bind variables). The
* number of executed batch operations corresponds to
* <code>[number of distinct rendered SQL statements]</code>. In the worst
* case, this corresponds to the number of total records.
* <p>
@ -4864,12 +4873,14 @@ public class Executor implements Configuration {
* <li>DELETE c1, c2</li>
* <li>DELETE a5</li>
* </ol>
* <h3>With
* <p>
* <h5>With
* <code>{@link Settings#getStatementType()} == {@link StatementType#STATIC_STATEMENT}</code>
* </h3> This mode may be better for large and complex batch delete
* operations, as the order of records is preserved entirely, and jOOQ can
* guarantee that only a single batch statement is serialised to the
* database.
* </h5>
* <p>
* This mode may be better for large and complex batch delete operations, as
* the order of records is preserved entirely, and jOOQ can guarantee that
* only a single batch statement is serialised to the database.
*
* @see Statement#executeBatch()
*/

8
jOOQ/src/main/java/org/jooq/impl/Factory.java
View File

@ -160,9 +160,11 @@ import org.jooq.types.DayToSecond;
* Condition condition = Factory.exists(Factory.select(...));
* </pre></code>
* <p>
* <h3>Factory and static imports</h3> For increased fluency and readability of
* your jOOQ client code, it is recommended that you static import all methods
* from the <code>Factory</code>. For example: <code><pre>
* <h5>Factory and static imports</h5>
* <p>
* For increased fluency and readability of your jOOQ client code, it is
* recommended that you static import all methods from the <code>Factory</code>.
* For example: <code><pre>
* import static org.jooq.impl.Factory.*;
*
* public class Main {