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

[jOOQ/jOOQ#13072] Remove experimental status on Row[N].mapping(Function[N])

Browse Source
This commit is contained in:
Lukas Eder 2022-02-15 09:16:55 +01:00
parent be001af097
commit dbd7b51daa
22 changed files with 132 additions and 308 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
jOOQ/src/main/java/org/jooq/Row1.java
View File

@ -91,27 +91,19 @@ public interface Row1<T1> extends Row, SelectField<Record1<T1>> {
/**
* A convenience method to define a local {@link Record1} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function1)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function1)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function1)} or
* {@link Functions#nullOnAnyNull(Function1)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function1<? super T1, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row10.java
View File

@ -91,27 +91,19 @@ public interface Row10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> extends Row, Sel
/**
* A convenience method to define a local {@link Record10} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function10)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function10)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function10)} or
* {@link Functions#nullOnAnyNull(Function10)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function10<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row11.java
View File

@ -91,27 +91,19 @@ public interface Row11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> extends Row
/**
* A convenience method to define a local {@link Record11} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function11)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function11)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function11)} or
* {@link Functions#nullOnAnyNull(Function11)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function11<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row12.java
View File

@ -91,27 +91,19 @@ public interface Row12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> extend
/**
* A convenience method to define a local {@link Record12} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function12)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function12)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function12)} or
* {@link Functions#nullOnAnyNull(Function12)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function12<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row13.java
View File

@ -91,27 +91,19 @@ public interface Row13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> e
/**
* A convenience method to define a local {@link Record13} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function13)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function13)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function13)} or
* {@link Functions#nullOnAnyNull(Function13)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function13<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row14.java
View File

@ -91,27 +91,19 @@ public interface Row14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
/**
* A convenience method to define a local {@link Record14} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function14)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function14)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function14)} or
* {@link Functions#nullOnAnyNull(Function14)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function14<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? super T14, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row15.java
View File

@ -91,27 +91,19 @@ public interface Row15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
/**
* A convenience method to define a local {@link Record15} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function15)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function15)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function15)} or
* {@link Functions#nullOnAnyNull(Function15)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function15<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? super T14, ? super T15, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row16.java
View File

@ -91,27 +91,19 @@ public interface Row16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
/**
* A convenience method to define a local {@link Record16} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function16)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function16)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function16)} or
* {@link Functions#nullOnAnyNull(Function16)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function16<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? super T14, ? super T15, ? super T16, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row17.java
View File

@ -91,27 +91,19 @@ public interface Row17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
/**
* A convenience method to define a local {@link Record17} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function17)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function17)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function17)} or
* {@link Functions#nullOnAnyNull(Function17)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function17<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? super T14, ? super T15, ? super T16, ? super T17, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row18.java
View File

@ -91,27 +91,19 @@ public interface Row18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
/**
* A convenience method to define a local {@link Record18} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function18)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function18)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function18)} or
* {@link Functions#nullOnAnyNull(Function18)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function18<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? super T14, ? super T15, ? super T16, ? super T17, ? super T18, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row19.java
View File

@ -91,27 +91,19 @@ public interface Row19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
/**
* A convenience method to define a local {@link Record19} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function19)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function19)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function19)} or
* {@link Functions#nullOnAnyNull(Function19)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function19<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? super T14, ? super T15, ? super T16, ? super T17, ? super T18, ? super T19, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row2.java
View File

@ -91,27 +91,19 @@ public interface Row2<T1, T2> extends Row, SelectField<Record2<T1, T2>> {
/**
* A convenience method to define a local {@link Record2} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function2)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function2)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function2)} or
* {@link Functions#nullOnAnyNull(Function2)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function2<? super T1, ? super T2, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row20.java
View File

@ -91,27 +91,19 @@ public interface Row20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
/**
* A convenience method to define a local {@link Record20} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function20)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function20)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function20)} or
* {@link Functions#nullOnAnyNull(Function20)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function20<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? super T14, ? super T15, ? super T16, ? super T17, ? super T18, ? super T19, ? super T20, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row21.java
View File

@ -91,27 +91,19 @@ public interface Row21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
/**
* A convenience method to define a local {@link Record21} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function21)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function21)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function21)} or
* {@link Functions#nullOnAnyNull(Function21)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function21<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? super T14, ? super T15, ? super T16, ? super T17, ? super T18, ? super T19, ? super T20, ? super T21, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row22.java
View File

@ -91,27 +91,19 @@ public interface Row22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T
/**
* A convenience method to define a local {@link Record22} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function22)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function22)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function22)} or
* {@link Functions#nullOnAnyNull(Function22)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function22<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? super T10, ? super T11, ? super T12, ? super T13, ? super T14, ? super T15, ? super T16, ? super T17, ? super T18, ? super T19, ? super T20, ? super T21, ? super T22, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row3.java
View File

@ -91,27 +91,19 @@ public interface Row3<T1, T2, T3> extends Row, SelectField<Record3<T1, T2, T3>>
/**
* A convenience method to define a local {@link Record3} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function3)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function3)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function3)} or
* {@link Functions#nullOnAnyNull(Function3)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function3<? super T1, ? super T2, ? super T3, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row4.java
View File

@ -91,27 +91,19 @@ public interface Row4<T1, T2, T3, T4> extends Row, SelectField<Record4<T1, T2, T
/**
* A convenience method to define a local {@link Record4} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function4)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function4)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function4)} or
* {@link Functions#nullOnAnyNull(Function4)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function4<? super T1, ? super T2, ? super T3, ? super T4, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row5.java
View File

@ -91,27 +91,19 @@ public interface Row5<T1, T2, T3, T4, T5> extends Row, SelectField<Record5<T1, T
/**
* A convenience method to define a local {@link Record5} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function5)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function5)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function5)} or
* {@link Functions#nullOnAnyNull(Function5)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function5<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row6.java
View File

@ -91,27 +91,19 @@ public interface Row6<T1, T2, T3, T4, T5, T6> extends Row, SelectField<Record6<T
/**
* A convenience method to define a local {@link Record6} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function6)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function6)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function6)} or
* {@link Functions#nullOnAnyNull(Function6)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function6<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row7.java
View File

@ -91,27 +91,19 @@ public interface Row7<T1, T2, T3, T4, T5, T6, T7> extends Row, SelectField<Recor
/**
* A convenience method to define a local {@link Record7} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function7)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function7)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function7)} or
* {@link Functions#nullOnAnyNull(Function7)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function7<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row8.java
View File

@ -91,27 +91,19 @@ public interface Row8<T1, T2, T3, T4, T5, T6, T7, T8> extends Row, SelectField<R
/**
* A convenience method to define a local {@link Record8} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function8)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function8)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function8)} or
* {@link Functions#nullOnAnyNull(Function8)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function8<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? extends U> function);
/**

20
jOOQ/src/main/java/org/jooq/Row9.java
View File

@ -91,27 +91,19 @@ public interface Row9<T1, T2, T3, T4, T5, T6, T7, T8, T9> extends Row, SelectFie
/**
* A convenience method to define a local {@link Record9} to custom type
* {@link RecordMapper} that can be used when projecting {@link Row} types in
* <code>SELECT</code> or <code>RETURNING</code> clauses.
* {@link RecordMapper} that can be used when projecting {@link Row} types
* in <code>SELECT</code> or <code>RETURNING</code> clauses.
* <p>
* EXPERIMENTAL. Unlike {@link #mapping(Class, Function9)}, this method
* attempts to work without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}. There may be some edge cases where this doesn't
* work. Please report any bugs here:
* <a href="https://github.com/jOOQ/jOOQ/issues/new/choose">https://github.com/jOOQ/jOOQ/issues/new/choose</a>
* Unlike {@link #mapping(Class, Function9)}, this method attempts to work
* without an explicit {@link Class} reference for the underlying
* {@link Converter#toType()}, e.g. when nesting rows in arrays, the class
* literal is required for reflective array creation.
* <p>
* Combine this with e.g. {@link Functions#nullOnAllNull(Function9)} or
* {@link Functions#nullOnAnyNull(Function9)} to achieve <code>null</code>
* safety when mapping nested rows from <code>LEFT JOIN</code> etc.
* <p>
* Known issues include:
* <p>
* <ul>
* <li>When nesting rows in arrays, the class literal is required for reflective array creation.</li>
* </ul>
*/
@NotNull
@Internal
<U> SelectField<U> mapping(Function9<? super T1, ? super T2, ? super T3, ? super T4, ? super T5, ? super T6, ? super T7, ? super T8, ? super T9, ? extends U> function);
/**