[#6021] Add DSLContext.with(Name, Name...)
This commit is contained in:
lukaseder
parent
ded601094b
commit
44dee26b63
@ -3880,6 +3880,380 @@ public interface DSLContext extends Scope , AutoCloseable {
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep22 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep1 with(Name alias, Name fieldAlias1);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep2 with(Name alias, Name fieldAlias1, Name fieldAlias2);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep3 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep4 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep5 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep6 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep7 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep8 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep9 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep10 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep11 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep12 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep13 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep14 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep15 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep16 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep17 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep18 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep19 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep20 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep21 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
WithAsStep22 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22);
|
||||
|
||||
// [jooq-tools] END [with]
|
||||
|
||||
/**
|
||||
@ -4434,6 +4808,446 @@ public interface DSLContext extends Scope , AutoCloseable {
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep22 withRecursive(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep1 withRecursive(Name alias, Name fieldAlias1);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep2 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep3 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep4 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep5 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep6 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep7 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep8 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep9 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep10 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep11 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep12 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep13 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep14 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep15 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep16 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep17 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep18 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep19 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep20 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep21 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21);
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep22 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22);
|
||||
|
||||
// [jooq-tools] END [with-recursive]
|
||||
|
||||
/**
|
||||
|
||||
@ -88,6 +88,18 @@ public interface WithStep extends QueryPart {
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep with(String alias, String... fieldAliases);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep with(Name alias);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep with(Name alias, Name... fieldAliases);
|
||||
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
@ -266,6 +278,160 @@ public interface WithStep extends QueryPart {
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep22 with(String alias, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep1 with(Name alias, Name fieldAlias1);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep2 with(Name alias, Name fieldAlias1, Name fieldAlias2);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep3 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep4 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep5 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep6 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep7 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep8 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep9 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep10 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep11 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep12 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep13 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep14 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep15 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep16 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep17 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep18 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep19 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep20 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep21 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21);
|
||||
|
||||
/**
|
||||
* Add another common table expression to the <code>WITH</code> clause.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
WithAsStep22 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22);
|
||||
|
||||
// [jooq-tools] END [with]
|
||||
|
||||
/**
|
||||
|
||||
@ -1139,6 +1139,424 @@ public class DSL {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep1 with(Name alias, Name fieldAlias1) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep2 with(Name alias, Name fieldAlias1, Name fieldAlias2) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep3 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep4 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep5 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep6 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep7 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep8 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep9 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep10 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep11 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep12 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep13 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep14 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep15 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep16 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep17 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep18 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep19 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep20 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep21 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, HSQLDB, POSTGRES })
|
||||
public static WithAsStep22 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22) {
|
||||
return new WithImpl(null, false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
|
||||
}
|
||||
|
||||
// [jooq-tools] END [with]
|
||||
|
||||
/**
|
||||
@ -1722,6 +2140,490 @@ public class DSL {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep1 withRecursive(Name alias, Name fieldAlias1) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep2 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep3 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep4 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep5 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep6 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep7 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep8 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep9 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep10 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep11 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep12 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep13 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep14 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep15 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep16 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep17 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep18 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep19 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep20 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep21 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a <code>WITH</code> clause to supply subsequent
|
||||
* <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code>,
|
||||
* <code>DELETE</code>, and <code>MERGE</code> statements with
|
||||
* {@link CommonTableExpression}s.
|
||||
* <p>
|
||||
* The <code>RECURSIVE</code> keyword may be optional or unsupported in some
|
||||
* databases, in case of which it will not be rendered. For optimal database
|
||||
* interoperability and readability, however, it is suggested that you use
|
||||
* {@link #with(String, String...)} for strictly non-recursive CTE
|
||||
* and {@link #withRecursive(String, String...)} for strictly
|
||||
* recursive CTE.
|
||||
* <p>
|
||||
* Note that the {@link SQLDialect#H2} database only supports single-table,
|
||||
* <code>RECURSIVE</code> common table expression lists.
|
||||
*/
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Support({ FIREBIRD, H2, HSQLDB, POSTGRES })
|
||||
public static WithAsStep22 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22) {
|
||||
return new WithImpl(null, true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
|
||||
}
|
||||
|
||||
// [jooq-tools] END [with-recursive]
|
||||
|
||||
/**
|
||||
|
||||
@ -1547,6 +1547,138 @@ public class DefaultDSLContext extends AbstractScope implements DSLContext, Seri
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep1 with(Name alias, Name fieldAlias1) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep2 with(Name alias, Name fieldAlias1, Name fieldAlias2) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep3 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep4 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep5 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep6 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep7 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep8 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep9 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep10 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep11 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep12 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep13 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep14 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep15 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep16 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep17 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep18 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep19 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep20 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep21 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep22 with(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22) {
|
||||
return new WithImpl(configuration(), false).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
|
||||
}
|
||||
|
||||
// [jooq-tools] END [with]
|
||||
|
||||
@Override
|
||||
@ -1710,6 +1842,138 @@ public class DefaultDSLContext extends AbstractScope implements DSLContext, Seri
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep1 withRecursive(Name alias, Name fieldAlias1) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep2 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep3 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep4 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep5 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep6 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep7 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep8 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep9 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep10 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep11 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep12 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep13 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep14 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep15 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep16 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep17 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep18 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep19 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep20 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep21 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21);
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public WithAsStep22 withRecursive(Name alias, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22) {
|
||||
return new WithImpl(configuration(), true).with(alias, fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22);
|
||||
}
|
||||
|
||||
// [jooq-tools] END [with-recursive]
|
||||
|
||||
@Override
|
||||
|
||||
@ -542,12 +542,8 @@ class ParserImpl implements Parser {
|
||||
// [#6022] Allow unquoted identifiers for columns
|
||||
parse(ctx, '(');
|
||||
List<Name> columnNames = parseIdentifiers(ctx);
|
||||
String[] columns = new String[columnNames.size()];
|
||||
for (int i = 0; i < columns.length; i++)
|
||||
columns[i] = columnNames.get(i).last();
|
||||
parse(ctx, ')');
|
||||
|
||||
DerivedColumnList dcl = table.fields(columns);
|
||||
DerivedColumnList dcl = table.fields(columnNames.toArray(EMPTY_NAME));
|
||||
parseKeyword(ctx, "AS");
|
||||
parse(ctx, '(');
|
||||
cte.add(dcl.as(parseSelect(ctx)));
|
||||
|
||||
@ -60,6 +60,7 @@ import org.jooq.Context;
|
||||
import org.jooq.Field;
|
||||
import org.jooq.InsertSetStep;
|
||||
import org.jooq.MergeUsingStep;
|
||||
import org.jooq.Name;
|
||||
import org.jooq.Record;
|
||||
import org.jooq.Record1;
|
||||
import org.jooq.Record10;
|
||||
@ -165,8 +166,8 @@ implements
|
||||
|
||||
// Intermediary properties for CTE construction
|
||||
|
||||
private String alias;
|
||||
private String[] fieldAliases;
|
||||
private Name alias;
|
||||
private Name[] fieldAliases;
|
||||
|
||||
private BiFunction<? super Field<?>, ? super Integer, ? extends String> fieldNameFunction;
|
||||
|
||||
@ -224,12 +225,22 @@ implements
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep with(String a) {
|
||||
return with(a, new String[0]);
|
||||
public final WithImpl with(String a) {
|
||||
return with(DSL.name(a));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep with(String a, String... f) {
|
||||
public final WithImpl with(String a, String... f) {
|
||||
return with(DSL.name(a), Tools.names(f));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a) {
|
||||
return with(a, new Name[0]);
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name... f) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = f;
|
||||
|
||||
@ -238,16 +249,16 @@ implements
|
||||
|
||||
|
||||
@Override
|
||||
public final WithAsStep with(String a, Function<? super Field<?>, ? extends String> f) {
|
||||
this.alias = a;
|
||||
public final WithImpl with(String a, Function<? super Field<?>, ? extends String> f) {
|
||||
this.alias = DSL.name(a);
|
||||
this.fieldNameFunction = (field, i) -> f.apply(field);
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep with(String a, BiFunction<? super Field<?>, ? super Integer, ? extends String> f) {
|
||||
this.alias = a;
|
||||
public final WithImpl with(String a, BiFunction<? super Field<?>, ? super Integer, ? extends String> f) {
|
||||
this.alias = DSL.name(a);
|
||||
this.fieldNameFunction = f;
|
||||
|
||||
return this;
|
||||
@ -257,179 +268,223 @@ implements
|
||||
// [jooq-tools] START [with]
|
||||
|
||||
@Override
|
||||
public final WithAsStep1 with(String a, String fieldAlias1) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep2 with(String a, String fieldAlias1, String fieldAlias2) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep3 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep4 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep5 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep6 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep7 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep8 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep9 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep10 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep11 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep12 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep13 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep14 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep15 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep16 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep17 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep18 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep19 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep20 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep21 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21 };
|
||||
|
||||
return this;
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21 }));
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithAsStep22 with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22) {
|
||||
this.alias = a;
|
||||
this.fieldAliases = new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22 };
|
||||
public final WithImpl with(String a, String fieldAlias1, String fieldAlias2, String fieldAlias3, String fieldAlias4, String fieldAlias5, String fieldAlias6, String fieldAlias7, String fieldAlias8, String fieldAlias9, String fieldAlias10, String fieldAlias11, String fieldAlias12, String fieldAlias13, String fieldAlias14, String fieldAlias15, String fieldAlias16, String fieldAlias17, String fieldAlias18, String fieldAlias19, String fieldAlias20, String fieldAlias21, String fieldAlias22) {
|
||||
return with(DSL.name(a), Tools.names(new String[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22 }));
|
||||
}
|
||||
|
||||
return this;
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1) {
|
||||
return with(a, new Name[] { fieldAlias1 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21 });
|
||||
}
|
||||
|
||||
@Override
|
||||
public final WithImpl with(Name a, Name fieldAlias1, Name fieldAlias2, Name fieldAlias3, Name fieldAlias4, Name fieldAlias5, Name fieldAlias6, Name fieldAlias7, Name fieldAlias8, Name fieldAlias9, Name fieldAlias10, Name fieldAlias11, Name fieldAlias12, Name fieldAlias13, Name fieldAlias14, Name fieldAlias15, Name fieldAlias16, Name fieldAlias17, Name fieldAlias18, Name fieldAlias19, Name fieldAlias20, Name fieldAlias21, Name fieldAlias22) {
|
||||
return with(a, new Name[] { fieldAlias1, fieldAlias2, fieldAlias3, fieldAlias4, fieldAlias5, fieldAlias6, fieldAlias7, fieldAlias8, fieldAlias9, fieldAlias10, fieldAlias11, fieldAlias12, fieldAlias13, fieldAlias14, fieldAlias15, fieldAlias16, fieldAlias17, fieldAlias18, fieldAlias19, fieldAlias20, fieldAlias21, fieldAlias22 });
|
||||
}
|
||||
|
||||
// [jooq-tools] END [with]
|
||||
@ -763,133 +818,133 @@ implements
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1> InsertImpl insertInto(Table<R> into, Field<T1> field1) {
|
||||
public final <R extends Record, T1> InsertImpl insertInto(Table<R> into, Field<T1> field1) {
|
||||
return insertInto(into, Arrays.asList(field1));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2) {
|
||||
public final <R extends Record, T1, T2> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2) {
|
||||
return insertInto(into, Arrays.asList(field1, field2));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3) {
|
||||
public final <R extends Record, T1, T2, T3> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4) {
|
||||
public final <R extends Record, T1, T2, T3, T4> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> InsertImpl insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22) {
|
||||
return insertInto(into, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22));
|
||||
}
|
||||
|
||||
@ -919,133 +974,133 @@ implements
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1> MergeImpl mergeInto(Table<R> table, Field<T1> field1) {
|
||||
public final <R extends Record, T1> MergeImpl mergeInto(Table<R> table, Field<T1> field1) {
|
||||
return mergeInto(table, Arrays.asList(field1));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2) {
|
||||
public final <R extends Record, T1, T2> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3) {
|
||||
public final <R extends Record, T1, T2, T3> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4) {
|
||||
public final <R extends Record, T1, T2, T3, T4> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21));
|
||||
}
|
||||
|
||||
@Generated("This method was generated using jOOQ-tools")
|
||||
@Override
|
||||
public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22) {
|
||||
public final <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> MergeImpl mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22) {
|
||||
return mergeInto(table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22));
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user