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

[jOOQ/jOOQ#17684] Add Javadoc to XJC generated enum types and literals

Browse Source
This commit is contained in:
Lukas Eder 2024-11-28 10:49:02 +01:00
parent 1817dfaf39
commit 2991aa3824
56 changed files with 1654 additions and 366 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/ForcedTypeObjectType.java
View File

@ -27,11 +27,41 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ForcedTypeObjectType {
/**
* A {@link ForcedType} should match all database object types.
*
*/
ALL,
/**
* A {@link ForcedType} should match only UDT attributes.
*
*/
ATTRIBUTE,
/**
* A {@link ForcedType} should match only table columns.
*
*/
COLUMN,
/**
* A {@link ForcedType} should match only array elements.
*
*/
ELEMENT,
/**
* A {@link ForcedType} should match only routine parameters.
*
*/
PARAMETER,
/**
* A {@link ForcedType} should match only sequences.
*
*/
SEQUENCE;
public String value() {

25
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedAnnotationType.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum GeneratedAnnotationType {
/**
* The <code>Generated</code> annotation should be detected automatically from the JDK used at code generation time.
*
*/
DETECT_FROM_JDK,
/**
* Use the <code>javax.annotation.Generated</code> annotation.
*
*/
JAVAX_ANNOTATION_GENERATED,
/**
* Use the <code>javax.annotation.processing.Generated</code> annotation.
*
*/
JAVAX_ANNOTATION_PROCESSING_GENERATED,
/**
* Use the <code>jakarta.annotation.Generated</code> annotation.
*
*/
JAKARTA_ANNOTATION_GENERATED,
/**
* Use the {@link org.jooq.Generated} annotation.
*
*/
ORG_JOOQ_GENERATED;
public String value() {

15
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedSerialVersionUID.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum GeneratedSerialVersionUID {
/**
* The generated serialVersionUID should be based on a hash code taken from the generated content.
*
*/
HASH,
/**
* The generated serialVersionUID should be constant.
*
*/
CONSTANT,
/**
* No serialVersionUID should be generated.
*
*/
OFF;
public String value() {

15
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedTextBlocks.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum GeneratedTextBlocks {
/**
* Text blocks should be used in generated code (for database source code) depending on whether the JDK used for code generation supports text blocks.
*
*/
DETECT_FROM_JDK,
/**
* Text blocks should be used in generated code (for database source code).
*
*/
ON,
/**
* Text blocks should not be used in generated code.
*
*/
OFF;
public String value() {

30
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Logging.java
View File

@ -27,11 +27,41 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum Logging {
/**
* The <code>TRACE</code> log level.
*
*/
TRACE,
/**
* The <code>DEBUG</code> log level.
*
*/
DEBUG,
/**
* The <code>INFO</code> log level.
*
*/
INFO,
/**
* The <code>WARN</code> log level.
*
*/
WARN,
/**
* The <code>ERROR</code> log level.
*
*/
ERROR,
/**
* The <code>FATAL</code> log level.
*
*/
FATAL;
public String value() {

35
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/MatcherTransformType.java
View File

@ -28,12 +28,47 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum MatcherTransformType {
/**
* A {@link MatcherRule} should not transform identifiers, but output them "as is" (as the input is).
*
*/
AS_IS,
/**
* A {@link MatcherRule} should transform identifiers to lower case.
*
*/
LOWER,
/**
* A {@link MatcherRule} should transform the first letters of identifiers to lower case.
*
*/
LOWER_FIRST_LETTER,
/**
* A {@link MatcherRule} should transform identifiers to UPPER case.
*
*/
UPPER,
/**
* A {@link MatcherRule} should transform the first letters of identifiers to UPPER case.
*
*/
UPPER_FIRST_LETTER,
/**
* A {@link MatcherRule} should transform identifiers to camelCase.
*
*/
CAMEL,
/**
* A {@link MatcherRule} should transform identifiers to PascalCase.
*
*/
PASCAL;
public String value() {

15
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Nullability.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum Nullability {
/**
* A {@link ForcedType} should match all columns, attributes, and parameters, irrespective of nullability.
*
*/
ALL,
/**
* A {@link ForcedType} should match only columns, attributes, and parameters, which are nullable.
*
*/
NULL,
/**
* A {@link ForcedType} should match only columns, attributes, and parameters, which are non-nullable.
*
*/
NOT_NULL;
public String value() {

15
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/OnError.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum OnError {
/**
* On error, the code generation should fail.
*
*/
FAIL,
/**
* On error, the code generation should log the error, and continue.
*
*/
LOG,
/**
* Suppress all errors.
*
*/
SILENT;
public String value() {

45
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/RegexFlag.java
View File

@ -30,14 +30,59 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RegexFlag {
/**
* Apply the {@link java.util.regex.Pattern#UNIX_LINES} flag to regular expressions from the code generation configuration.
*
*/
UNIX_LINES,
/**
* Apply the {@link java.util.regex.Pattern#CASE_INSENSITIVE} flag to regular expressions from the code generation configuration.
*
*/
CASE_INSENSITIVE,
/**
* Apply the {@link java.util.regex.Pattern#COMMENTS} flag to regular expressions from the code generation configuration.
*
*/
COMMENTS,
/**
* Apply the {@link java.util.regex.Pattern#MULTILINE} flag to regular expressions from the code generation configuration.
*
*/
MULTILINE,
/**
* Apply the {@link java.util.regex.Pattern#LITERAL} flag to regular expressions from the code generation configuration.
*
*/
LITERAL,
/**
* Apply the {@link java.util.regex.Pattern#DOTALL} flag to regular expressions from the code generation configuration.
*
*/
DOTALL,
/**
* Apply the {@link java.util.regex.Pattern#UNICODE_CASE} flag to regular expressions from the code generation configuration.
*
*/
UNICODE_CASE,
/**
* Apply the {@link java.util.regex.Pattern#CANON_EQ} flag to regular expressions from the code generation configuration.
*
*/
CANON_EQ,
/**
* Apply the {@link java.util.regex.Pattern#UNICODE_CHARACTER_CLASS} flag to regular expressions from the code generation configuration.
*
*/
UNICODE_CHARACTER_CLASS;
public String value() {

25
jOOQ-meta/src/main/java/org/jooq/meta/jaxb/VisibilityModifier.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum VisibilityModifier {
/**
* The generated visibility modifier is the default for the target language to produce <code>public</code> visibility (explicit <code>public</code> in Java, nothing in Kotlin, Scala).
*
*/
DEFAULT,
/**
* No visibility modifier is generated.
*
*/
NONE,
/**
* An explicit <code>public</code> visibility modifier is generated, where supported (no modifier is generated in Scala).
*
*/
PUBLIC,
/**
* An explicit <code>internal</code> visibility modifier is generated, where supported (or <code>public</code>, otherwise).
*
*/
INTERNAL,
/**
* A <code>private</code> visibility modifier is generated. This is useful only for {@link ForcedType}, not as a global configuration.
*
*/
PRIVATE;
public String value() {

216
jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.20.0.xsd
View File

@ -40,20 +40,38 @@
<simpleType name="Logging">
<restriction base="string">
<enumeration value="TRACE"/>
<enumeration value="DEBUG"/>
<enumeration value="INFO"/>
<enumeration value="WARN"/>
<enumeration value="ERROR"/>
<enumeration value="FATAL"/>
<enumeration value="TRACE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The <code>TRACE</code> log level.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="DEBUG">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The <code>DEBUG</code> log level.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="INFO">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The <code>INFO</code> log level.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="WARN">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The <code>WARN</code> log level.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="ERROR">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The <code>ERROR</code> log level.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="FATAL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The <code>FATAL</code> log level.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="OnError">
<restriction base="string">
<enumeration value="FAIL"/>
<enumeration value="LOG"/>
<enumeration value="SILENT"/>
<enumeration value="FAIL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[On error, the code generation should fail.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="LOG">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[On error, the code generation should log the error, and continue.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="SILENT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Suppress all errors.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
@ -881,13 +899,27 @@ and follow its (undocumented!) assumptions (e.g. constructors, etc.). Use this a
<simpleType name="MatcherTransformType">
<restriction base="string">
<enumeration value="AS_IS"/>
<enumeration value="LOWER"/>
<enumeration value="LOWER_FIRST_LETTER"/>
<enumeration value="UPPER"/>
<enumeration value="UPPER_FIRST_LETTER"/>
<enumeration value="CAMEL"/>
<enumeration value="PASCAL"/>
<enumeration value="AS_IS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link MatcherRule} should not transform identifiers, but output them "as is" (as the input is).]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="LOWER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link MatcherRule} should transform identifiers to lower case.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="LOWER_FIRST_LETTER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link MatcherRule} should transform the first letters of identifiers to lower case.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="UPPER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link MatcherRule} should transform identifiers to UPPER case.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="UPPER_FIRST_LETTER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link MatcherRule} should transform the first letters of identifiers to UPPER case.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="CAMEL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link MatcherRule} should transform identifiers to camelCase.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="PASCAL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link MatcherRule} should transform identifiers to PascalCase.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
@ -2514,12 +2546,24 @@ type. If provided, both "includeExpression" and "includeTypes" must match.]]></j
<simpleType name="ForcedTypeObjectType">
<restriction base="string">
<enumeration value="ALL"/>
<enumeration value="ATTRIBUTE"/>
<enumeration value="COLUMN"/>
<enumeration value="ELEMENT"/>
<enumeration value="PARAMETER"/>
<enumeration value="SEQUENCE"/>
<enumeration value="ALL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link ForcedType} should match all database object types.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="ATTRIBUTE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link ForcedType} should match only UDT attributes.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="COLUMN">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link ForcedType} should match only table columns.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="ELEMENT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link ForcedType} should match only array elements.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="PARAMETER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link ForcedType} should match only routine parameters.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="SEQUENCE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link ForcedType} should match only sequences.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
@ -3234,68 +3278,132 @@ e.g. org.jooq.generated.schema1, org.jooq.generated.schema2]]></jxb:javadoc></jx
<simpleType name="RegexFlag">
<restriction base="string">
<enumeration value="UNIX_LINES"/>
<enumeration value="CASE_INSENSITIVE"/>
<enumeration value="COMMENTS"/>
<enumeration value="MULTILINE"/>
<enumeration value="LITERAL"/>
<enumeration value="DOTALL"/>
<enumeration value="UNICODE_CASE"/>
<enumeration value="CANON_EQ"/>
<enumeration value="UNICODE_CHARACTER_CLASS"/>
<enumeration value="UNIX_LINES">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the {@link java.util.regex.Pattern#UNIX_LINES} flag to regular expressions from the code generation configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="CASE_INSENSITIVE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the {@link java.util.regex.Pattern#CASE_INSENSITIVE} flag to regular expressions from the code generation configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="COMMENTS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the {@link java.util.regex.Pattern#COMMENTS} flag to regular expressions from the code generation configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="MULTILINE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the {@link java.util.regex.Pattern#MULTILINE} flag to regular expressions from the code generation configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="LITERAL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the {@link java.util.regex.Pattern#LITERAL} flag to regular expressions from the code generation configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="DOTALL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the {@link java.util.regex.Pattern#DOTALL} flag to regular expressions from the code generation configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="UNICODE_CASE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the {@link java.util.regex.Pattern#UNICODE_CASE} flag to regular expressions from the code generation configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="CANON_EQ">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the {@link java.util.regex.Pattern#CANON_EQ} flag to regular expressions from the code generation configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="UNICODE_CHARACTER_CLASS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the {@link java.util.regex.Pattern#UNICODE_CHARACTER_CLASS} flag to regular expressions from the code generation configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="JpaVersion">
<restriction base="string">
<enumeration value="1.0"/>
<enumeration value="2.0"/>
<enumeration value="2.1"/>
<enumeration value="2.2"/>
<enumeration value="1.0">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Assume JPA 1.0 support, or later, in generated code.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="2.0">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Assume JPA 2.0 support, or later, in generated code.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="2.1">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Assume JPA 2.1 support, or later, in generated code.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="2.2">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Assume JPA 2.2 support, or later, in generated code.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="Nullability">
<restriction base="string">
<enumeration value="ALL"/>
<enumeration value="NULL"/>
<enumeration value="NOT_NULL"/>
<enumeration value="ALL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link ForcedType} should match all columns, attributes, and parameters, irrespective of nullability.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="NULL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link ForcedType} should match only columns, attributes, and parameters, which are nullable.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="NOT_NULL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A {@link ForcedType} should match only columns, attributes, and parameters, which are non-nullable.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="VisibilityModifier">
<restriction base="string">
<enumeration value="DEFAULT"/>
<enumeration value="NONE"/>
<enumeration value="PUBLIC"/>
<enumeration value="INTERNAL"/>
<enumeration value="PRIVATE"/>
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The generated visibility modifier is the default for the target language to produce <code>public</code> visibility (explicit <code>public</code> in Java, nothing in Kotlin, Scala).]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="NONE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[No visibility modifier is generated.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="PUBLIC">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[An explicit <code>public</code> visibility modifier is generated, where supported (no modifier is generated in Scala).]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="INTERNAL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[An explicit <code>internal</code> visibility modifier is generated, where supported (or <code>public</code>, otherwise).]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="PRIVATE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[A <code>private</code> visibility modifier is generated. This is useful only for {@link ForcedType}, not as a global configuration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="GeneratedAnnotationType">
<restriction base="string">
<enumeration value="DETECT_FROM_JDK"/>
<enumeration value="JAVAX_ANNOTATION_GENERATED"/>
<enumeration value="JAVAX_ANNOTATION_PROCESSING_GENERATED"/>
<enumeration value="JAKARTA_ANNOTATION_GENERATED"/>
<enumeration value="ORG_JOOQ_GENERATED"/>
<enumeration value="DETECT_FROM_JDK">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The <code>Generated</code> annotation should be detected automatically from the JDK used at code generation time.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="JAVAX_ANNOTATION_GENERATED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Use the <code>javax.annotation.Generated</code> annotation.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="JAVAX_ANNOTATION_PROCESSING_GENERATED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Use the <code>javax.annotation.processing.Generated</code> annotation.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="JAKARTA_ANNOTATION_GENERATED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Use the <code>jakarta.annotation.Generated</code> annotation.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="ORG_JOOQ_GENERATED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Use the {@link org.jooq.Generated} annotation.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="GeneratedTextBlocks">
<restriction base="string">
<enumeration value="DETECT_FROM_JDK"/>
<enumeration value="ON"/>
<enumeration value="OFF"/>
<enumeration value="DETECT_FROM_JDK">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Text blocks should be used in generated code (for database source code) depending on whether the JDK used for code generation supports text blocks.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="ON">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Text blocks should be used in generated code (for database source code).]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="OFF">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Text blocks should not be used in generated code.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="GeneratedSerialVersionUID">
<restriction base="string">
<enumeration value="HASH"/>
<enumeration value="CONSTANT"/>
<enumeration value="OFF"/>
<enumeration value="HASH">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The generated serialVersionUID should be based on a hash code taken from the generated content.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="CONSTANT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The generated serialVersionUID should be constant.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="OFF">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[No serialVersionUID should be generated.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
</schema>

15
jOOQ/src/main/java/org/jooq/conf/AutoAliasExpressions.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum AutoAliasExpressions {
/**
* Never auto-alias expressions.
*
*/
NEVER,
/**
* Auto-alias only unnamed expressions.
*
*/
UNNAMED,
/**
* Always auto-alias expressions.
*
*/
ALWAYS;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/BackslashEscaping.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum BackslashEscaping {
/**
* Use the database's most sensible default value for ON (MySQL, MariaDB) / OFF (all other databases)
*
*/
DEFAULT,
/**
* Always escape backslashes.
*
*/
ON,
/**
* Never escape backslashes.
*
*/
OFF;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/DiagnosticsConnection.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum DiagnosticsConnection {
/**
* The DiagnosticsConnection is turned on if used explicitly.
*
*/
DEFAULT,
/**
* The DiagnosticsConnection is always turned on for any user connection.
*
*/
ON,
/**
* The DiagnosticsConnection is turned off, even when used explicitly.
*
*/
OFF;
public String value() {

25
jOOQ/src/main/java/org/jooq/conf/ExecuteWithoutWhere.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ExecuteWithoutWhere {
/**
* UPDATE and DELETE statements are allowed to lack a WHERE clause
*
*/
IGNORE,
/**
* UPDATE and DELETE statements are allowed to lack a WHERE clause, but this is logged as DEBUG level
*
*/
LOG_DEBUG,
/**
* UPDATE and DELETE statements are allowed to lack a WHERE clause, but this is logged as INFO level
*
*/
LOG_INFO,
/**
* UPDATE and DELETE statements are allowed to lack a WHERE clause, but this is logged as WARN level
*
*/
LOG_WARN,
/**
* UPDATE and DELETE statements are not allowed to lack a WHERE clause
*
*/
THROW;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/FetchIntermediateResult.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum FetchIntermediateResult {
/**
* Always fetch intermediate results
*
*/
ALWAYS,
/**
* Fetch intermediate results only when explicitly requested or when execute listeners are present
*
*/
WHEN_EXECUTE_LISTENERS_PRESENT,
/**
* Fetch intermediate results only when explicitly requested
*
*/
WHEN_RESULT_REQUESTED;
public String value() {

16
jOOQ/src/main/java/org/jooq/conf/FetchTriggerValuesAfterReturning.java
View File

@ -24,8 +24,24 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum FetchTriggerValuesAfterReturning {
/**
* Never fetch trigger values after returning.
*
*/
NEVER,
/**
* Fetch trigger values only when triggers are known to be present.
* Trigger meta data is only available in jOOQ's commercial editions
*
*/
WHEN_NEEDED,
/**
* Always fetch trigger values.
*
*/
ALWAYS;
public String value() {

20
jOOQ/src/main/java/org/jooq/conf/InterpreterNameLookupCaseSensitivity.java
View File

@ -25,9 +25,29 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum InterpreterNameLookupCaseSensitivity {
/**
* The default value depending on Settings.interpreterDialect
*
*/
DEFAULT,
/**
* Identifiers are always case sensitive
*
*/
ALWAYS,
/**
* Only quoted identifiers are case sensitive
*
*/
WHEN_QUOTED,
/**
* Identifiers are never case sensitive
*
*/
NEVER;
public String value() {

10
jOOQ/src/main/java/org/jooq/conf/InvocationOrder.java
View File

@ -23,7 +23,17 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum InvocationOrder {
/**
* The first registered listener is invoked first
*
*/
DEFAULT,
/**
* The first registered listener is invoked last
*
*/
REVERSE;
public String value() {

25
jOOQ/src/main/java/org/jooq/conf/NestedCollectionEmulation.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum NestedCollectionEmulation {
/**
* Generate native LIST, SET, MULTISET syntax irrespective of support
*
*/
NATIVE,
/**
* Generate native LIST, SET, MULTISET syntax if supported, or the most optimal emulation, otherwise
*
*/
DEFAULT,
/**
* Emulate LIST, SET, MULTISET syntax using XML
*
*/
XML,
/**
* Emulate LIST, SET, MULTISET syntax using JSON
*
*/
JSON,
/**
* Emulate LIST, SET, MULTISET syntax using JSONB
*
*/
JSONB;
public String value() {

20
jOOQ/src/main/java/org/jooq/conf/ParamCastMode.java
View File

@ -24,8 +24,28 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ParamCastMode {
/**
* Bind values are always cast to their respective type.
*
*/
ALWAYS,
/**
* Bind values are cast to their respective type when needed.
*
* Some databases are not able to delay bind value type inference until the execution of a statement.
* They will either reject the value of unknown type, or assume a possibly inappropriate type. In these
* cases, jOOQ will generate an explicit cast(? as datatype) expression around the bind value to help
* the query parser do its job. The exact behaviour of this mode is undefined and subject to change.
*
*/
DEFAULT,
/**
* Bind values are never cast to their respective type.
*
*/
NEVER;
public String value() {

25
jOOQ/src/main/java/org/jooq/conf/ParamType.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ParamType {
/**
* Execute statements with indexed parameters, the way JDBC expects them.
*
*/
INDEXED,
/**
* Execute statements with indexed parameters, forcing explicit inlined and named parameters to be indexed as well.
*
*/
FORCE_INDEXED,
/**
* Execute statements with named parameters.
*
*/
NAMED,
/**
* Execute statements with named parameters, if a name is given, or inlined parameters otherwise.
*
*/
NAMED_OR_INLINED,
/**
* Execute statements with inlined parameters.
*
*/
INLINED;
public String value() {

30
jOOQ/src/main/java/org/jooq/conf/ParseNameCase.java
View File

@ -27,11 +27,41 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ParseNameCase {
/**
* Parse object names, as defined in the database. For instance: schema.TABLE
*
*/
AS_IS,
/**
* Force parsing object names in lower case. For instance: schema."table"
*
*/
LOWER,
/**
* Force parsing object names in lower case, if unquoted. For instance schema."TABLE"
*
*/
LOWER_IF_UNQUOTED,
/**
* Force parsing object names in upper case. For instance: SCHEMA."TABLE"
*
*/
UPPER,
/**
* Force parsing object names in upper case, if unquoted. For instance SCHEMA."table"
*
*/
UPPER_IF_UNQUOTED,
/**
* Apply the parse dialect specific default behaviour
*
*/
DEFAULT;
public String value() {

10
jOOQ/src/main/java/org/jooq/conf/ParseUnknownFunctions.java
View File

@ -23,7 +23,17 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ParseUnknownFunctions {
/**
* Functions have to be known by the parser, or by the catalog.
*
*/
FAIL,
/**
* Unknown functions (parser or catalog) will be passed on as plain SQL.
*
*/
IGNORE;
public String value() {

10
jOOQ/src/main/java/org/jooq/conf/ParseUnsupportedSyntax.java
View File

@ -23,7 +23,17 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ParseUnsupportedSyntax {
/**
* Fail on syntax that is supported (known) by the parser, but not the jOOQ API
*
*/
FAIL,
/**
* Ignore syntax that is supported (known) by the parser, but not the jOOQ API
*
*/
IGNORE;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/ParseWithMetaLookups.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ParseWithMetaLookups {
/**
* Meta lookups are deactivated in parser
*
*/
OFF,
/**
* Meta lookups are active in parser, but don't throw exceptions on failure
*
*/
IGNORE_ON_FAILURE,
/**
* Meta lookups are active in parser and throw exceptions on failure
*
*/
THROW_ON_FAILURE;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/QueryPoolable.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum QueryPoolable {
/**
* Statements are poolable
*
*/
TRUE,
/**
* Statements are not poolable
*
*/
FALSE,
/**
* Statements may be poolable, according to JDBC's default behaviour
*
*/
DEFAULT;
public String value() {

10
jOOQ/src/main/java/org/jooq/conf/RecordDirtyTracking.java
View File

@ -23,7 +23,17 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RecordDirtyTracking {
/**
* Dirty tracking is based on Record.touched() semantics
*
*/
TOUCHED,
/**
* Dirty tracking is based on Record.modified() semantics
*
*/
MODIFIED;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/RenderDefaultNullability.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RenderDefaultNullability {
/**
* Do not produce any nullability clause for Nullability.DEFAULT, and thus produce the dialect specific default behaviors
*
*/
IMPLICIT_DEFAULT,
/**
* Produce implicit nullability for Nullability.DEFAULT if NULL is the default for a given dialect, or explicit nullability otherwise (e.g. in both Sybase)
*
*/
IMPLICIT_NULL,
/**
* Produce explicit nullability for Nullability.DEFAULT, irrespective of the context (e.g. if the column is a primary key)
*
*/
EXPLICIT_NULL;
public String value() {

25
jOOQ/src/main/java/org/jooq/conf/RenderImplicitJoinType.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RenderImplicitJoinType {
/**
* The DEFAULT behaviour, depending on the type of path
*
*/
DEFAULT,
/**
* Always render INNER JOIN
*
*/
INNER_JOIN,
/**
* Always render LEFT JOIN
*
*/
LEFT_JOIN,
/**
* Always render a scalar subquery
*
*/
SCALAR_SUBQUERY,
/**
* Always throw an exception (effectively disallowing the type of implicit joins)
*
*/
THROW;
public String value() {

25
jOOQ/src/main/java/org/jooq/conf/RenderImplicitWindowRange.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RenderImplicitWindowRange {
/**
* Implicit RANGE clause will not be generated explicitly. The RDBMS's implicit behaviour is used
*
*/
OFF,
/**
* Implicit RANGE clause is generated as ROWS UNBOUNDED PRECEDING
*
*/
ROWS_UNBOUNDED_PRECEDING,
/**
* Implicit RANGE clause is generated as ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
*
*/
ROWS_ALL,
/**
* Implicit RANGE clause is generated as RANGE UNBOUNDED PRECEDING
*
*/
RANGE_UNBOUNDED_PRECEDING,
/**
* Implicit RANGE clause is generated as RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
*
*/
RANGE_ALL;
public String value() {

24
jOOQ/src/main/java/org/jooq/conf/RenderKeywordCase.java
View File

@ -25,9 +25,33 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RenderKeywordCase {
/**
* Keywords are rendered "as is", i.e. mostly in lower case. For instance:
* select .. from .. where ..
*
*/
AS_IS,
/**
* Keywords are rendered in lower case. For instance:
* select .. from .. where ..
*
*/
LOWER,
/**
* Keywords are rendered in upper case. For instance:
* SELECT .. FROM .. WHERE ..
*
*/
UPPER,
/**
* Keywords are rendered in Pascal Case. For instance:
* Select .. From .. Where ..
*
*/
PASCAL;
public String value() {

24
jOOQ/src/main/java/org/jooq/conf/RenderKeywordStyle.java
View File

@ -26,9 +26,33 @@ import jakarta.xml.bind.annotation.XmlType;
@Deprecated
public enum RenderKeywordStyle {
/**
* Keywords are rendered "as is", i.e. mostly in lower case. For instance:
* select .. from .. where ..
*
*/
AS_IS,
/**
* Keywords are rendered in lower case. For instance:
* select .. from .. where ..
*
*/
LOWER,
/**
* Keywords are rendered in upper case. For instance:
* SELECT .. FROM .. WHERE ..
*
*/
UPPER,
/**
* Keywords are rendered in Pascal Case. For instance:
* Select .. From .. Where ..
*
*/
PASCAL;
public String value() {

25
jOOQ/src/main/java/org/jooq/conf/RenderNameCase.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RenderNameCase {
/**
* Render object names, as defined in the database. For instance: schema.TABLE
*
*/
AS_IS,
/**
* Force rendering object names in lower case. For instance: schema."table"
*
*/
LOWER,
/**
* Force rendering object names in lower case, if unquoted. For instance schema."TABLE"
*
*/
LOWER_IF_UNQUOTED,
/**
* Force rendering object names in upper case. For instance: SCHEMA."TABLE"
*
*/
UPPER,
/**
* Force rendering object names in upper case, if unquoted. For instance SCHEMA."table"
*
*/
UPPER_IF_UNQUOTED;
public String value() {

34
jOOQ/src/main/java/org/jooq/conf/RenderNameStyle.java
View File

@ -26,9 +26,43 @@ import jakarta.xml.bind.annotation.XmlType;
@Deprecated
public enum RenderNameStyle {
/**
* Render object names quoted, as defined in the database. Use this
* to stay on the safe side with case-sensitivity and special
* characters. For instance:
* Oracle : "SYS"."ALL_TAB_COLS"
* MySQL : `information_schema`.`TABLES`
* SQL Server: [INFORMATION_SCHEMA].[TABLES]
*
*/
QUOTED,
/**
* Render object names, as defined in the database. For instance:
* Oracle : SYS.ALL_TAB_COLS
* MySQL : information_schema.TABLES
* SQL Server: INFORMATION_SCHEMA.TABLES
*
*/
AS_IS,
/**
* Force rendering object names in lower case. For instance:
* Oracle : sys.all_tab_cols
* MySQL : information_schema.tables
* SQL Server: information_schema.tables
*
*/
LOWER,
/**
* Force rendering object names in upper case. For instance:
* Oracle : SYS.ALL_TAB_COLS
* MySQL : INFORMATION_SCHEMA.TABLES
* SQL Server: INFORMATION_SCHEMA.TABLES
*
*/
UPPER;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/RenderOptionalKeyword.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RenderOptionalKeyword {
/**
* Optional keywords will never be generated (does not affect mandatory keywords).
*
*/
OFF,
/**
* Optional keywords will always be generated (does not affect mandatory keywords).
*
*/
ON,
/**
* The default applies for optional keywords.
*
*/
DEFAULT;
public String value() {

25
jOOQ/src/main/java/org/jooq/conf/RenderQuotedNames.java
View File

@ -25,9 +25,34 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RenderQuotedNames {
/**
* Always render object names quoted, as defined in the database.
* Use this to stay on the safe side with case-sensitivity, special
* characters, and keywords. For instance:
* Oracle : "SYS"."ALL_TAB_COLS"
* MySQL : `information_schema`.`TABLES`
* SQL Server: [INFORMATION_SCHEMA].[TABLES]
*
*/
ALWAYS,
/**
* Render object names quoted if they are constructed using DSL.quotedName() or DSL.name()
*
*/
EXPLICIT_DEFAULT_QUOTED,
/**
* Render object names quoted if they are constructed using DSL.quotedName()
*
*/
EXPLICIT_DEFAULT_UNQUOTED,
/**
* Never quote names
*
*/
NEVER;
public String value() {

10
jOOQ/src/main/java/org/jooq/conf/StatementType.java
View File

@ -23,7 +23,17 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum StatementType {
/**
* Execute statements with inlined bind values, avoiding JDBC's PreparedStatements
*
*/
STATIC_STATEMENT,
/**
* Execute statements with bind values, using JDBC's PreparedStatements
*
*/
PREPARED_STATEMENT;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/ThrowExceptions.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ThrowExceptions {
/**
* Collect all exceptions from a batch and throw them all together
*
*/
THROW_ALL,
/**
* Throw only the first exception from a batch
*
*/
THROW_FIRST,
/**
* Throw no exceptions, but collect them in ResultOrRows
*
*/
THROW_NONE;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/TransformUnneededArithmeticExpressions.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum TransformUnneededArithmeticExpressions {
/**
* Never transform unneeded arithmetic expressions
*
*/
NEVER,
/**
* Transform arithmetic expressions arising from jOOQ's internals
*
*/
INTERNAL,
/**
* Transform all arithmetic expressions
*
*/
ALWAYS;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/Transformation.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum Transformation {
/**
* Never apply the transformation
*
*/
NEVER,
/**
* Apply the transformation when needed by a dialect
*
*/
WHEN_NEEDED,
/**
* Always apply the transformation
*
*/
ALWAYS;
public String value() {

20
jOOQ/src/main/java/org/jooq/conf/UpdateUnchangedRecords.java
View File

@ -25,9 +25,29 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum UpdateUnchangedRecords {
/**
* Never update unchanged records
*
*/
NEVER,
/**
* Update unchanged records by setting the primary key column to itself, e.g. SET id = id
*
*/
SET_PRIMARY_KEY_TO_ITSELF,
/**
* Update unchanged records by setting non-primary key columns to themselves, e.g. SET a = a, b = b
*
*/
SET_NON_PRIMARY_KEY_TO_THEMSELVES,
/**
* Update unchanged records by setting record values to the values from the record, e.g. SET a = :a, b = :b. This is the same as calling record.changed(true) prior to updating.
*
*/
SET_NON_PRIMARY_KEY_TO_RECORD_VALUES;
public String value() {

25
jOOQ/src/main/java/org/jooq/conf/Warning.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum Warning {
/**
* Ignore a warning
*
*/
IGNORE,
/**
* Log a warning at DEBUG level
*
*/
LOG_DEBUG,
/**
* Log a warning at INFO level
*
*/
LOG_INFO,
/**
* Log a warning at WARN level
*
*/
LOG_WARN,
/**
* Throw an exception
*
*/
THROW;
public String value() {

15
jOOQ/src/main/java/org/jooq/conf/WriteIfReadonly.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum WriteIfReadonly {
/**
* Allow for writing to readonly fields
*
*/
WRITE,
/**
* Ignore writes to readonly fields
*
*/
IGNORE,
/**
* Throw an exception when writing to readonly fields
*
*/
THROW;
public String value() {

25
jOOQ/src/main/java/org/jooq/migrations/xml/jaxb/ChangeType.java
View File

@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ChangeType {
/**
* ADD a file to the migration.
*
*/
ADD,
/**
* MODIFY a file from the migration.
*
*/
MODIFY,
/**
* DELETE a file from the migration.
*
*/
DELETE,
/**
* RENAME a file in the migration.
*
*/
RENAME,
/**
* COPY a file within the migration.
*
*/
COPY;
public String value() {

25
jOOQ/src/main/java/org/jooq/util/xml/jaxb/ForeignKeyRule.java
View File

@ -27,12 +27,37 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ForeignKeyRule {
/**
* The DELETE or UPDATE rule is for changes to the referenced table to CASCADE to the referencing table.
*
*/
CASCADE("CASCADE"),
/**
* The DELETE or UPDATE rule is for changes to the referenced table to result in SET NULL actions in the referencing table.
*
*/
@XmlEnumValue("SET NULL")
SET_NULL("SET NULL"),
/**
* The DELETE or UPDATE rule is for changes to the referenced table to result in SET DELETE actions in the referencing table.
*
*/
@XmlEnumValue("SET DEFAULT")
SET_DEFAULT("SET DEFAULT"),
/**
* The DELETE or UPDATE rule is to RESTRICT changes to the referenced table.
*
*/
RESTRICT("RESTRICT"),
/**
* The DELETE or UPDATE rule is to take NO ACTION on changes to the referenced table. This is similar to {@link #RESTRICT}, but allows for checks to be deferred.
*
*/
@XmlEnumValue("NO ACTION")
NO_ACTION("NO ACTION");
private final String value;

15
jOOQ/src/main/java/org/jooq/util/xml/jaxb/ParameterMode.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum ParameterMode {
/**
* The parameter is an IN parameter.
*
*/
IN,
/**
* The parameter is an IN/OUT parameter.
*
*/
INOUT,
/**
* The parameter is an OUT parameter.
*
*/
OUT;
public String value() {

10
jOOQ/src/main/java/org/jooq/util/xml/jaxb/RoutineType.java
View File

@ -23,7 +23,17 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum RoutineType {
/**
* The routine is a FUNCTION.
*
*/
FUNCTION,
/**
* The routine is a PROCEDURE.
*
*/
PROCEDURE;
public String value() {

20
jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableConstraintType.java
View File

@ -26,10 +26,30 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum TableConstraintType {
/**
* The constraint is a PRIMARY KEY constraint.
*
*/
@XmlEnumValue("PRIMARY KEY")
PRIMARY_KEY("PRIMARY KEY"),
/**
* The constraint is a UNIQUE constraint.
*
*/
UNIQUE("UNIQUE"),
/**
* The constraint is a CHECK constraint.
*
*/
CHECK("CHECK"),
/**
* The constraint is a FOREIGN KEY constraint.
*
*/
@XmlEnumValue("FOREIGN KEY")
FOREIGN_KEY("FOREIGN KEY");
private final String value;

20
jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableType.java
View File

@ -26,11 +26,31 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum TableType {
/**
* The table is an ordinary table, or a table whose type isn't recognised by jOOQ (yet).
*
*/
@XmlEnumValue("BASE TABLE")
BASE_TABLE("BASE TABLE"),
/**
* The table is a VIEW.
*
*/
VIEW("VIEW"),
/**
* The table is a MATERIALIZED VIEW.
*
*/
@XmlEnumValue("MATERIALIZED VIEW")
MATERIALIZED_VIEW("MATERIALIZED VIEW"),
/**
* The table is a TEMPORARY table.
*
*/
@XmlEnumValue("GLOBAL TEMPORARY")
GLOBAL_TEMPORARY("GLOBAL TEMPORARY");
private final String value;

10
jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionOrientation.java
View File

@ -23,7 +23,17 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum TriggerActionOrientation {
/**
* Whether the trigger should fire once per ROW.
*
*/
ROW,
/**
* Whether the trigger should fire once per STATEMENT.
*
*/
STATEMENT;
public String value() {

15
jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionTiming.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum TriggerActionTiming {
/**
* Whether the trigger should fire BEFORE each {@link TriggerActionOrientation#ROW} or {@link TriggerActionOrientation#STATEMENT}.
*
*/
BEFORE,
/**
* Whether the trigger should fire AFTER each {@link TriggerActionOrientation#ROW} or {@link TriggerActionOrientation#STATEMENT}.
*
*/
AFTER,
/**
* Whether the trigger should fire INSTEAD OF each {@link TriggerActionOrientation#ROW} or {@link TriggerActionOrientation#STATEMENT}.
*
*/
INSTEAD_OF;
public String value() {

15
jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerEventManipulation.java
View File

@ -24,8 +24,23 @@ import jakarta.xml.bind.annotation.XmlType;
@XmlEnum
public enum TriggerEventManipulation {
/**
* Whether the trigger should fire on INSERT.
*
*/
INSERT,
/**
* Whether the trigger should fire on UPDATE.
*
*/
UPDATE,
/**
* Whether the trigger should fire on DELETE.
*
*/
DELETE;
public String value() {

110
jOOQ/src/main/resources/org/jooq/xsd/jooq-meta-3.20.0.xsd
View File

@ -1,8 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://www.jooq.org/xsd/jooq-meta-3.20.0.xsd"
xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
xmlns:annox="http://annox.dev.java.net"
targetNamespace="http://www.jooq.org/xsd/jooq-meta-3.20.0.xsd"
elementFormDefault="qualified">
elementFormDefault="qualified"
jxb:extensionBindingPrefixes="annox"
jxb:version="2.1">
<element name="information_schema">
<complexType>
@ -424,24 +428,40 @@
<simpleType name="TriggerEventManipulation">
<restriction base="string">
<enumeration value="INSERT"/>
<enumeration value="UPDATE"/>
<enumeration value="DELETE"/>
<enumeration value="INSERT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Whether the trigger should fire on INSERT.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="UPDATE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Whether the trigger should fire on UPDATE.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="DELETE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Whether the trigger should fire on DELETE.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="TriggerActionOrientation">
<restriction base="string">
<enumeration value="ROW"/>
<enumeration value="STATEMENT"/>
<enumeration value="ROW">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Whether the trigger should fire once per ROW.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="STATEMENT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Whether the trigger should fire once per STATEMENT.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="TriggerActionTiming">
<restriction base="string">
<enumeration value="BEFORE"/>
<enumeration value="AFTER"/>
<enumeration value="INSTEAD_OF"/>
<enumeration value="BEFORE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Whether the trigger should fire BEFORE each {@link TriggerActionOrientation#ROW} or {@link TriggerActionOrientation#STATEMENT}.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="AFTER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Whether the trigger should fire AFTER each {@link TriggerActionOrientation#ROW} or {@link TriggerActionOrientation#STATEMENT}.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="INSTEAD_OF">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Whether the trigger should fire INSTEAD OF each {@link TriggerActionOrientation#ROW} or {@link TriggerActionOrientation#STATEMENT}.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
@ -456,44 +476,80 @@
<simpleType name="ParameterMode">
<restriction base="string">
<enumeration value="IN"/>
<enumeration value="INOUT"/>
<enumeration value="OUT"/>
<enumeration value="IN">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The parameter is an IN parameter.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="INOUT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The parameter is an IN/OUT parameter.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="OUT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The parameter is an OUT parameter.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="RoutineType">
<restriction base="string">
<enumeration value="FUNCTION"/>
<enumeration value="PROCEDURE"/>
<enumeration value="FUNCTION">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The routine is a FUNCTION.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="PROCEDURE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The routine is a PROCEDURE.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="TableConstraintType">
<restriction base="string">
<enumeration value="PRIMARY KEY"/>
<enumeration value="UNIQUE"/>
<enumeration value="CHECK"/>
<enumeration value="FOREIGN KEY"/>
<enumeration value="PRIMARY KEY">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The constraint is a PRIMARY KEY constraint.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="UNIQUE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The constraint is a UNIQUE constraint.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="CHECK">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The constraint is a CHECK constraint.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="FOREIGN KEY">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The constraint is a FOREIGN KEY constraint.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="TableType">
<restriction base="string">
<enumeration value="BASE TABLE"/>
<enumeration value="VIEW"/>
<enumeration value="MATERIALIZED VIEW"/>
<enumeration value="GLOBAL TEMPORARY"/>
<enumeration value="BASE TABLE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The table is an ordinary table, or a table whose type isn't recognised by jOOQ (yet).]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="VIEW">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The table is a VIEW.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="MATERIALIZED VIEW">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The table is a MATERIALIZED VIEW.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="GLOBAL TEMPORARY">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The table is a TEMPORARY table.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="ForeignKeyRule">
<restriction base="string">
<enumeration value="CASCADE"/>
<enumeration value="SET NULL"/>
<enumeration value="SET DEFAULT"/>
<enumeration value="RESTRICT"/>
<enumeration value="NO ACTION"/>
<enumeration value="CASCADE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The DELETE or UPDATE rule is for changes to the referenced table to CASCADE to the referencing table.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="SET NULL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The DELETE or UPDATE rule is for changes to the referenced table to result in SET NULL actions in the referencing table.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="SET DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The DELETE or UPDATE rule is for changes to the referenced table to result in SET DELETE actions in the referencing table.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="RESTRICT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The DELETE or UPDATE rule is to RESTRICT changes to the referenced table.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="NO ACTION">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The DELETE or UPDATE rule is to take NO ACTION on changes to the referenced table. This is similar to {@link #RESTRICT}, but allows for checks to be deferred.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
</schema>

26
jOOQ/src/main/resources/org/jooq/xsd/jooq-migrations-3.20.0.xsd
View File

@ -1,8 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
xmlns:tns="http://www.jooq.org/xsd/jooq-migrations-3.20.0.xsd"
xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
xmlns:annox="http://annox.dev.java.net"
targetNamespace="http://www.jooq.org/xsd/jooq-migrations-3.20.0.xsd"
elementFormDefault="qualified">
elementFormDefault="qualified"
jxb:extensionBindingPrefixes="annox"
jxb:version="2.1">
<element name="migrations" type="tns:MigrationsType"/>
<element name="commit" type="tns:CommitType"/>
@ -72,11 +76,21 @@
<simpleType name="ChangeType">
<restriction base="string">
<enumeration value="ADD"/>
<enumeration value="MODIFY"/>
<enumeration value="DELETE"/>
<enumeration value="RENAME"/>
<enumeration value="COPY"/>
<enumeration value="ADD">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[ADD a file to the migration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="MODIFY">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[MODIFY a file from the migration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="DELETE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[DELETE a file from the migration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="RENAME">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[RENAME a file in the migration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<enumeration value="COPY">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[COPY a file within the migration.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
</schema>

645
jOOQ/src/main/resources/org/jooq/xsd/jooq-runtime-3.20.0.xsd
View File

@ -1951,62 +1951,71 @@ Either &lt;input/&gt; or &lt;inputExpression/&gt; must be provided]]></jxb:javad
<simpleType name="ParamType">
<restriction base="string">
<enumeration value="INDEXED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Execute statements with indexed parameters, the way JDBC expects them.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Execute statements with indexed parameters, the way JDBC expects them -->
<enumeration value="INDEXED"/>
<enumeration value="FORCE_INDEXED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Execute statements with indexed parameters, forcing explicit inlined and named parameters to be indexed as well.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Execute statements with indexed parameters, forcing explicit inlined and named parameters to be indexed as well -->
<enumeration value="FORCE_INDEXED"/>
<enumeration value="NAMED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Execute statements with named parameters.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Execute statements with named parameters -->
<enumeration value="NAMED"/>
<!-- Execute statements with named parameters, if a name is given, or inlined parameters otherwise -->
<enumeration value="NAMED_OR_INLINED"/>
<enumeration value="NAMED_OR_INLINED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Execute statements with named parameters, if a name is given, or inlined parameters otherwise.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Execute statements with inlined parameters -->
<enumeration value="INLINED"/>
<enumeration value="INLINED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Execute statements with inlined parameters.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="ParamCastMode">
<restriction base="string">
<enumeration value="ALWAYS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Bind values are always cast to their respective type.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Bind values are always cast to their respective type. -->
<enumeration value="ALWAYS"/>
<!-- Bind values are cast to their respective type when needed.
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Bind values are cast to their respective type when needed.
Some databases are not able to delay bind value type inference until the execution of a statement.
They will either reject the value of unknown type, or assume a possibly inappropriate type. In these
cases, jOOQ will generate an explicit cast(? as datatype) expression around the bind value to help
the query parser do its job. The exact behaviour of this mode is undefined and subject to change. -->
<enumeration value="DEFAULT"/>
the query parser do its job. The exact behaviour of this mode is undefined and subject to change.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Bind values are never cast to their respective type. -->
<enumeration value="NEVER"/>
<enumeration value="NEVER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Bind values are never cast to their respective type.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="StatementType">
<restriction base="string">
<enumeration value="STATIC_STATEMENT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Execute statements with inlined bind values, avoiding JDBC's PreparedStatements]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Execute statements with inlined bind values, avoiding JDBC's PreparedStatements -->
<enumeration value="STATIC_STATEMENT"/>
<!-- Execute statements with bind values, using JDBC's PreparedStatements -->
<enumeration value="PREPARED_STATEMENT"/>
<enumeration value="PREPARED_STATEMENT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Execute statements with bind values, using JDBC's PreparedStatements]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="InvocationOrder">
<restriction base="string">
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The first registered listener is invoked first]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- The first registered listener is invoked first -->
<enumeration value="DEFAULT"/>
<!-- The first registered listener is invoked last -->
<enumeration value="REVERSE"/>
<enumeration value="REVERSE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The first registered listener is invoked last]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
@ -2017,95 +2026,108 @@ Either &lt;input/&gt; or &lt;inputExpression/&gt; must be provided]]></jxb:javad
</appinfo>
</annotation>
<restriction base="string">
<!-- Render object names quoted, as defined in the database. Use this
<enumeration value="QUOTED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Render object names quoted, as defined in the database. Use this
to stay on the safe side with case-sensitivity and special
characters. For instance:
Oracle : "SYS"."ALL_TAB_COLS"
MySQL : `information_schema`.`TABLES`
SQL Server: [INFORMATION_SCHEMA].[TABLES] -->
<enumeration value="QUOTED"/>
SQL Server: [INFORMATION_SCHEMA].[TABLES]]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Render object names, as defined in the database. For instance:
<enumeration value="AS_IS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Render object names, as defined in the database. For instance:
Oracle : SYS.ALL_TAB_COLS
MySQL : information_schema.TABLES
SQL Server: INFORMATION_SCHEMA.TABLES -->
<enumeration value="AS_IS"/>
SQL Server: INFORMATION_SCHEMA.TABLES]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Force rendering object names in lower case. For instance:
<enumeration value="LOWER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force rendering object names in lower case. For instance:
Oracle : sys.all_tab_cols
MySQL : information_schema.tables
SQL Server: information_schema.tables -->
<enumeration value="LOWER"/>
SQL Server: information_schema.tables]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Force rendering object names in upper case. For instance:
<enumeration value="UPPER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force rendering object names in upper case. For instance:
Oracle : SYS.ALL_TAB_COLS
MySQL : INFORMATION_SCHEMA.TABLES
SQL Server: INFORMATION_SCHEMA.TABLES -->
<enumeration value="UPPER"/>
SQL Server: INFORMATION_SCHEMA.TABLES]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="RenderQuotedNames">
<restriction base="string">
<!-- Always render object names quoted, as defined in the database.
<enumeration value="ALWAYS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always render object names quoted, as defined in the database.
Use this to stay on the safe side with case-sensitivity, special
characters, and keywords. For instance:
Oracle : "SYS"."ALL_TAB_COLS"
MySQL : `information_schema`.`TABLES`
SQL Server: [INFORMATION_SCHEMA].[TABLES] -->
<enumeration value="ALWAYS"/>
SQL Server: [INFORMATION_SCHEMA].[TABLES]]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Render object names quoted if they are constructed using DSL.quotedName() or DSL.name() -->
<enumeration value="EXPLICIT_DEFAULT_QUOTED"/>
<enumeration value="EXPLICIT_DEFAULT_QUOTED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Render object names quoted if they are constructed using DSL.quotedName() or DSL.name()]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Render object names quoted if they are constructed using DSL.quotedName() -->
<enumeration value="EXPLICIT_DEFAULT_UNQUOTED"/>
<enumeration value="EXPLICIT_DEFAULT_UNQUOTED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Render object names quoted if they are constructed using DSL.quotedName()]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Never quote names -->
<enumeration value="NEVER"/>
<enumeration value="NEVER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Never quote names]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="RenderNameCase">
<restriction base="string">
<enumeration value="AS_IS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Render object names, as defined in the database. For instance: schema.TABLE]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Render object names, as defined in the database. For instance: schema.TABLE -->
<enumeration value="AS_IS"/>
<enumeration value="LOWER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force rendering object names in lower case. For instance: schema."table"]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Force rendering object names in lower case. For instance: schema."table" -->
<enumeration value="LOWER"/>
<enumeration value="LOWER_IF_UNQUOTED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force rendering object names in lower case, if unquoted. For instance schema."TABLE"]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Force rendering object names in lower case, if unquoted. For instance schema."TABLE" -->
<enumeration value="LOWER_IF_UNQUOTED"/>
<enumeration value="UPPER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force rendering object names in upper case. For instance: SCHEMA."TABLE"]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Force rendering object names in upper case. For instance: SCHEMA."TABLE" -->
<enumeration value="UPPER"/>
<!-- Force rendering object names in upper case, if unquoted. For instance SCHEMA."table" -->
<enumeration value="UPPER_IF_UNQUOTED"/>
<enumeration value="UPPER_IF_UNQUOTED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force rendering object names in upper case, if unquoted. For instance SCHEMA."table"]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="RenderKeywordCase">
<restriction base="string">
<enumeration value="AS_IS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Keywords are rendered "as is", i.e. mostly in lower case. For instance:
select .. from .. where ..]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Keywords are rendered "as is", i.e. mostly in lower case. For instance:
select .. from .. where .. -->
<enumeration value="AS_IS"/>
<enumeration value="LOWER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Keywords are rendered in lower case. For instance:
select .. from .. where ..]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Keywords are rendered in lower case. For instance:
select .. from .. where .. -->
<enumeration value="LOWER"/>
<enumeration value="UPPER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Keywords are rendered in upper case. For instance:
SELECT .. FROM .. WHERE ..]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Keywords are rendered in upper case. For instance:
SELECT .. FROM .. WHERE .. -->
<enumeration value="UPPER"/>
<!-- Keywords are rendered in Pascal Case. For instance:
Select .. From .. Where .. -->
<enumeration value="PASCAL"/>
<enumeration value="PASCAL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Keywords are rendered in Pascal Case. For instance:
Select .. From .. Where ..]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
@ -2116,22 +2138,25 @@ Either &lt;input/&gt; or &lt;inputExpression/&gt; must be provided]]></jxb:javad
</appinfo>
</annotation>
<restriction base="string">
<enumeration value="AS_IS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Keywords are rendered "as is", i.e. mostly in lower case. For instance:
select .. from .. where ..]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Keywords are rendered "as is", i.e. mostly in lower case. For instance:
select .. from .. where .. -->
<enumeration value="AS_IS"/>
<enumeration value="LOWER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Keywords are rendered in lower case. For instance:
select .. from .. where ..]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Keywords are rendered in lower case. For instance:
select .. from .. where .. -->
<enumeration value="LOWER"/>
<enumeration value="UPPER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Keywords are rendered in upper case. For instance:
SELECT .. FROM .. WHERE ..]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Keywords are rendered in upper case. For instance:
SELECT .. FROM .. WHERE .. -->
<enumeration value="UPPER"/>
<!-- Keywords are rendered in Pascal Case. For instance:
Select .. From .. Where .. -->
<enumeration value="PASCAL"/>
<enumeration value="PASCAL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Keywords are rendered in Pascal Case. For instance:
Select .. From .. Where ..]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
@ -2155,15 +2180,17 @@ Either &lt;input/&gt; or &lt;inputExpression/&gt; must be provided]]></jxb:javad
<simpleType name="DiagnosticsConnection">
<restriction base="string">
<!-- The DiagnosticsConnection is turned on if used explicitly. -->
<enumeration value="DEFAULT"/>
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The DiagnosticsConnection is turned on if used explicitly.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- The DiagnosticsConnection is always turned on for any user connection. -->
<enumeration value="ON"/>
<enumeration value="ON">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The DiagnosticsConnection is always turned on for any user connection.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- The DiagnosticsConnection is turned off, even when used explicitly. -->
<enumeration value="OFF"/>
<enumeration value="OFF">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The DiagnosticsConnection is turned off, even when used explicitly.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
@ -2177,367 +2204,427 @@ Either &lt;input/&gt; or &lt;inputExpression/&gt; must be provided]]></jxb:javad
<enumeration value="AUTO"/>
-->
<!-- Use the database's most sensible default value for ON (MySQL, MariaDB) / OFF (all other databases) -->
<enumeration value="DEFAULT"/>
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Use the database's most sensible default value for ON (MySQL, MariaDB) / OFF (all other databases)]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Always escape backslashes. -->
<enumeration value="ON"/>
<enumeration value="ON">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always escape backslashes.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Never escape backslashes. -->
<enumeration value="OFF"/>
<enumeration value="OFF">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Never escape backslashes.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="ThrowExceptions">
<restriction base="string">
<enumeration value="THROW_ALL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Collect all exceptions from a batch and throw them all together]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Collect all exceptions from a batch and throw them all together -->
<enumeration value="THROW_ALL"/>
<enumeration value="THROW_FIRST">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Throw only the first exception from a batch]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Throw only the first exception from a batch -->
<enumeration value="THROW_FIRST"/>
<!-- Throw no exceptions, but collect them in ResultOrRows -->
<enumeration value="THROW_NONE"/>
<enumeration value="THROW_NONE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Throw no exceptions, but collect them in ResultOrRows]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="ExecuteWithoutWhere">
<restriction base="string">
<enumeration value="IGNORE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[UPDATE and DELETE statements are allowed to lack a WHERE clause]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- UPDATE and DELETE statements are allowed to lack a WHERE clause -->
<enumeration value="IGNORE"/>
<enumeration value="LOG_DEBUG">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[UPDATE and DELETE statements are allowed to lack a WHERE clause, but this is logged as DEBUG level]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- UPDATE and DELETE statements are allowed to lack a WHERE clause, but this is logged as DEBUG level -->
<enumeration value="LOG_DEBUG"/>
<enumeration value="LOG_INFO">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[UPDATE and DELETE statements are allowed to lack a WHERE clause, but this is logged as INFO level]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- UPDATE and DELETE statements are allowed to lack a WHERE clause, but this is logged as INFO level -->
<enumeration value="LOG_INFO"/>
<enumeration value="LOG_WARN">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[UPDATE and DELETE statements are allowed to lack a WHERE clause, but this is logged as WARN level]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- UPDATE and DELETE statements are allowed to lack a WHERE clause, but this is logged as WARN level -->
<enumeration value="LOG_WARN"/>
<!-- UPDATE and DELETE statements are not allowed to lack a WHERE clause -->
<enumeration value="THROW"/>
<enumeration value="THROW">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[UPDATE and DELETE statements are not allowed to lack a WHERE clause]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="Warning">
<restriction base="string">
<enumeration value="IGNORE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Ignore a warning]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Ignore a warning -->
<enumeration value="IGNORE"/>
<enumeration value="LOG_DEBUG">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Log a warning at DEBUG level]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Log a warning at DEBUG level -->
<enumeration value="LOG_DEBUG"/>
<enumeration value="LOG_INFO">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Log a warning at INFO level]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Log a warning at INFO level -->
<enumeration value="LOG_INFO"/>
<enumeration value="LOG_WARN">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Log a warning at WARN level]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Log a warning at WARN level -->
<enumeration value="LOG_WARN"/>
<!-- Throw an exception -->
<enumeration value="THROW"/>
<enumeration value="THROW">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Throw an exception]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="RenderImplicitJoinType">
<restriction base="string">
<!-- The DEFAULT behaviour, depending on the type of path -->
<enumeration value="DEFAULT"/>
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The DEFAULT behaviour, depending on the type of path]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Always render INNER JOIN -->
<enumeration value="INNER_JOIN"/>
<enumeration value="INNER_JOIN">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always render INNER JOIN]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Always render LEFT JOIN -->
<enumeration value="LEFT_JOIN"/>
<enumeration value="LEFT_JOIN">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always render LEFT JOIN]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Always render a scalar subquery -->
<enumeration value="SCALAR_SUBQUERY"/>
<enumeration value="SCALAR_SUBQUERY">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always render a scalar subquery]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Always throw an exception (effectively disallowing the type of implicit joins) -->
<enumeration value="THROW"/>
<enumeration value="THROW">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always throw an exception (effectively disallowing the type of implicit joins)]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="RenderDefaultNullability">
<restriction base="string">
<!-- Do not produce any nullability clause for Nullability.DEFAULT, and thus produce the dialect specific default behaviors -->
<enumeration value="IMPLICIT_DEFAULT"/>
<enumeration value="IMPLICIT_DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Do not produce any nullability clause for Nullability.DEFAULT, and thus produce the dialect specific default behaviors]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Produce the dialect specific default behaviour, but generate it explicitly
<enumeration value="EXPLICIT_DEFAULT"/>
-->
<!-- Produce implicit nullability for Nullability.DEFAULT if NULL is the default for a given dialect, or explicit nullability otherwise (e.g. in both Sybase) -->
<enumeration value="IMPLICIT_NULL"/>
<enumeration value="IMPLICIT_NULL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Produce implicit nullability for Nullability.DEFAULT if NULL is the default for a given dialect, or explicit nullability otherwise (e.g. in both Sybase)]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Produce explicit nullability for Nullability.DEFAULT, irrespective of the context (e.g. if the column is a primary key) -->
<enumeration value="EXPLICIT_NULL"/>
<enumeration value="EXPLICIT_NULL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Produce explicit nullability for Nullability.DEFAULT, irrespective of the context (e.g. if the column is a primary key)]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="RenderOptionalKeyword">
<restriction base="string">
<!-- Optional keywords will never be generated (does not affect mandatory keywords). -->
<enumeration value="OFF"/>
<enumeration value="OFF">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Optional keywords will never be generated (does not affect mandatory keywords).]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Optional keywords will always be generated (does not affect mandatory keywords). -->
<enumeration value="ON"/>
<enumeration value="ON">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Optional keywords will always be generated (does not affect mandatory keywords).]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- The default applies for optional keywords. -->
<enumeration value="DEFAULT"/>
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The default applies for optional keywords.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="RenderImplicitWindowRange">
<restriction base="string">
<!-- Implicit RANGE clause will not be generated explicitly. The RDBMS's implicit behaviour is used -->
<enumeration value="OFF"/>
<enumeration value="OFF">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Implicit RANGE clause will not be generated explicitly. The RDBMS's implicit behaviour is used]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Implicit RANGE clause is generated as ROWS UNBOUNDED PRECEDING -->
<enumeration value="ROWS_UNBOUNDED_PRECEDING"/>
<enumeration value="ROWS_UNBOUNDED_PRECEDING">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Implicit RANGE clause is generated as ROWS UNBOUNDED PRECEDING]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Implicit RANGE clause is generated as ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING -->
<enumeration value="ROWS_ALL"/>
<enumeration value="ROWS_ALL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Implicit RANGE clause is generated as ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Implicit RANGE clause is generated as RANGE UNBOUNDED PRECEDING -->
<enumeration value="RANGE_UNBOUNDED_PRECEDING"/>
<enumeration value="RANGE_UNBOUNDED_PRECEDING">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Implicit RANGE clause is generated as RANGE UNBOUNDED PRECEDING]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Implicit RANGE clause is generated as RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING -->
<enumeration value="RANGE_ALL"/>
<enumeration value="RANGE_ALL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Implicit RANGE clause is generated as RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="InterpreterNameLookupCaseSensitivity">
<restriction base="string">
<!-- The default value depending on Settings.interpreterDialect -->
<enumeration value="DEFAULT"/>
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[The default value depending on Settings.interpreterDialect]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Identifiers are always case sensitive -->
<enumeration value="ALWAYS"/>
<enumeration value="ALWAYS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Identifiers are always case sensitive]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Only quoted identifiers are case sensitive -->
<enumeration value="WHEN_QUOTED"/>
<enumeration value="WHEN_QUOTED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Only quoted identifiers are case sensitive]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Identifiers are never case sensitive -->
<enumeration value="NEVER"/>
<enumeration value="NEVER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Identifiers are never case sensitive]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="ParseNameCase">
<restriction base="string">
<!-- Parse object names, as defined in the database. For instance: schema.TABLE -->
<enumeration value="AS_IS"/>
<enumeration value="AS_IS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Parse object names, as defined in the database. For instance: schema.TABLE]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Force parsing object names in lower case. For instance: schema."table" -->
<enumeration value="LOWER"/>
<enumeration value="LOWER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force parsing object names in lower case. For instance: schema."table"]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Force parsing object names in lower case, if unquoted. For instance schema."TABLE" -->
<enumeration value="LOWER_IF_UNQUOTED"/>
<enumeration value="LOWER_IF_UNQUOTED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force parsing object names in lower case, if unquoted. For instance schema."TABLE"]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Force parsing object names in upper case. For instance: SCHEMA."TABLE" -->
<enumeration value="UPPER"/>
<enumeration value="UPPER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force parsing object names in upper case. For instance: SCHEMA."TABLE"]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Force parsing object names in upper case, if unquoted. For instance SCHEMA."table" -->
<enumeration value="UPPER_IF_UNQUOTED"/>
<enumeration value="UPPER_IF_UNQUOTED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Force parsing object names in upper case, if unquoted. For instance SCHEMA."table"]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Apply the parse dialect specific default behaviour -->
<enumeration value="DEFAULT"></enumeration>
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the parse dialect specific default behaviour]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="ParseWithMetaLookups">
<restriction base="string">
<enumeration value="OFF">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Meta lookups are deactivated in parser]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Meta lookups are deactivated in parser -->
<enumeration value="OFF"/>
<enumeration value="IGNORE_ON_FAILURE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Meta lookups are active in parser, but don't throw exceptions on failure]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Meta lookups are active in parser, but don't throw exceptions on failure -->
<enumeration value="IGNORE_ON_FAILURE"/>
<!-- Meta lookups are active in parser and throw exceptions on failure -->
<enumeration value="THROW_ON_FAILURE"/>
<enumeration value="THROW_ON_FAILURE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Meta lookups are active in parser and throw exceptions on failure]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="ParseUnsupportedSyntax">
<restriction base="string">
<enumeration value="FAIL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Fail on syntax that is supported (known) by the parser, but not the jOOQ API]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Fail on syntax that is supported (known) by the parser, but not the jOOQ API -->
<enumeration value="FAIL"/>
<!-- Ignore syntax that is supported (known) by the parser, but not the jOOQ API -->
<enumeration value="IGNORE"/>
<enumeration value="IGNORE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Ignore syntax that is supported (known) by the parser, but not the jOOQ API]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="ParseUnknownFunctions">
<restriction base="string">
<enumeration value="FAIL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Functions have to be known by the parser, or by the catalog.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Functions have to be known by the parser, or by the catalog -->
<enumeration value="FAIL"/>
<!-- Unknown functions (parser or catalog) will be passed on as plain SQL -->
<enumeration value="IGNORE"/>
<enumeration value="IGNORE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Unknown functions (parser or catalog) will be passed on as plain SQL.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="QueryPoolable">
<restriction base="string">
<enumeration value="TRUE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Statements are poolable]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Statements are poolable -->
<enumeration value="TRUE"/>
<enumeration value="FALSE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Statements are not poolable]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Statements are not poolable -->
<enumeration value="FALSE"/>
<!-- Statements may be poolable, according to JDBC's default behaviour -->
<enumeration value="DEFAULT"/>
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Statements may be poolable, according to JDBC's default behaviour]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="UpdateUnchangedRecords">
<restriction base="string">
<enumeration value="NEVER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Never update unchanged records]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Never update unchanged records -->
<enumeration value="NEVER"/>
<enumeration value="SET_PRIMARY_KEY_TO_ITSELF">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Update unchanged records by setting the primary key column to itself, e.g. SET id = id]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Update unchanged records by setting the primary key column to itself, e.g. SET id = id -->
<enumeration value="SET_PRIMARY_KEY_TO_ITSELF"/>
<enumeration value="SET_NON_PRIMARY_KEY_TO_THEMSELVES">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Update unchanged records by setting non-primary key columns to themselves, e.g. SET a = a, b = b]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Update unchanged records by setting non-primary key columns to themselves, e.g. SET a = a, b = b -->
<enumeration value="SET_NON_PRIMARY_KEY_TO_THEMSELVES"/>
<!-- Update unchanged records by setting record values to the values from the record, e.g. SET a = :a, b = :b. This is the same as calling record.changed(true) prior to updating. -->
<enumeration value="SET_NON_PRIMARY_KEY_TO_RECORD_VALUES"/>
<enumeration value="SET_NON_PRIMARY_KEY_TO_RECORD_VALUES">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Update unchanged records by setting record values to the values from the record, e.g. SET a = :a, b = :b. This is the same as calling record.changed(true) prior to updating.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="RecordDirtyTracking">
<restriction base="string">
<!-- Dirty tracking is based on Record.touched() semantics -->
<enumeration value="TOUCHED"/>
<enumeration value="TOUCHED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Dirty tracking is based on Record.touched() semantics]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Dirty tracking is based on Record.modified() semantics -->
<enumeration value="MODIFIED"/>
<enumeration value="MODIFIED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Dirty tracking is based on Record.modified() semantics]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="Transformation">
<restriction base="string">
<!-- Never apply the transformation -->
<enumeration value="NEVER"/>
<enumeration value="NEVER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Never apply the transformation]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Apply the transformation when needed by a dialect -->
<enumeration value="WHEN_NEEDED"/>
<enumeration value="WHEN_NEEDED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Apply the transformation when needed by a dialect]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Always apply the transformation -->
<enumeration value="ALWAYS"/>
<enumeration value="ALWAYS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always apply the transformation]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="TransformUnneededArithmeticExpressions">
<restriction base="string">
<!-- Never transform unneeded arithmetic expressions -->
<enumeration value="NEVER"/>
<enumeration value="NEVER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Never transform unneeded arithmetic expressions]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Transform arithmetic expressions arising from jOOQ's internals -->
<enumeration value="INTERNAL"/>
<enumeration value="INTERNAL">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Transform arithmetic expressions arising from jOOQ's internals]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Transform all arithmetic expressions -->
<enumeration value="ALWAYS"/>
<enumeration value="ALWAYS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Transform all arithmetic expressions]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="FetchIntermediateResult">
<restriction base="string">
<enumeration value="ALWAYS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always fetch intermediate results]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Always fetch intermediate results -->
<enumeration value="ALWAYS"/>
<enumeration value="WHEN_EXECUTE_LISTENERS_PRESENT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Fetch intermediate results only when explicitly requested or when execute listeners are present]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Fetch intermediate results only when explicitly requested or when execute listeners are present -->
<enumeration value="WHEN_EXECUTE_LISTENERS_PRESENT"/>
<!-- Fetch intermediate results only when explicitly requested -->
<enumeration value="WHEN_RESULT_REQUESTED"/>
<enumeration value="WHEN_RESULT_REQUESTED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Fetch intermediate results only when explicitly requested]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="NestedCollectionEmulation">
<restriction base="string">
<enumeration value="NATIVE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Generate native LIST, SET, MULTISET syntax irrespective of support]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Generate native LIST, SET, MULTISET syntax irrespective of support -->
<enumeration value="NATIVE"/>
<!-- Generate native LIST, SET, MULTISET syntax if supported, or the most optimal emulation, otherwise -->
<enumeration value="DEFAULT"/>
<enumeration value="DEFAULT">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Generate native LIST, SET, MULTISET syntax if supported, or the most optimal emulation, otherwise]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Emulate LIST, SET, MULTISET syntax using ARRAY and ROW
<enumeration value="ARRAY"/>
-->
<!-- Emulate LIST, SET, MULTISET syntax using XML -->
<enumeration value="XML"/>
<enumeration value="XML">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Emulate LIST, SET, MULTISET syntax using XML]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Emulate LIST, SET, MULTISET syntax using JSON -->
<enumeration value="JSON"/>
<enumeration value="JSON">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Emulate LIST, SET, MULTISET syntax using JSON]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Emulate LIST, SET, MULTISET syntax using JSONB -->
<enumeration value="JSONB"/>
<enumeration value="JSONB">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Emulate LIST, SET, MULTISET syntax using JSONB]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="WriteIfReadonly">
<restriction base="string">
<!-- Allow for writing to readonly fields -->
<enumeration value="WRITE"/>
<enumeration value="WRITE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Allow for writing to readonly fields]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Ignore writes to readonly fields -->
<enumeration value="IGNORE"/>
<enumeration value="IGNORE">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Ignore writes to readonly fields]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Throw an exception when writing to readonly fields -->
<enumeration value="THROW"/>
<enumeration value="THROW">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Throw an exception when writing to readonly fields]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="FetchTriggerValuesAfterReturning">
<restriction base="string">
<!-- Never fetch trigger values after returning. -->
<enumeration value="NEVER"/>
<enumeration value="NEVER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Never fetch trigger values after returning.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Fetch trigger values only when triggers are known to be present.
Trigger meta data is only available in jOOQ's commercial editions -->
<enumeration value="WHEN_NEEDED"/>
<enumeration value="WHEN_NEEDED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Fetch trigger values only when triggers are known to be present.
Trigger meta data is only available in jOOQ's commercial editions]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Always fetch trigger values. -->
<enumeration value="ALWAYS"/>
<enumeration value="ALWAYS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always fetch trigger values.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
<simpleType name="AutoAliasExpressions">
<restriction base="string">
<!-- Never auto-alias expressions. -->
<enumeration value="NEVER"/>
<enumeration value="NEVER">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Never auto-alias expressions.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Auto-alias only unnamed expressions. -->
<enumeration value="UNNAMED"/>
<enumeration value="UNNAMED">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Auto-alias only unnamed expressions.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
<!-- Always auto-alias expressions. -->
<enumeration value="ALWAYS"/>
<enumeration value="ALWAYS">
<annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Always auto-alias expressions.]]></jxb:javadoc></jxb:property></appinfo></annotation>
</enumeration>
</restriction>
</simpleType>
</schema>