diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/ForcedTypeObjectType.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/ForcedTypeObjectType.java index 2b2db50155..97bfc49af0 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/ForcedTypeObjectType.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/ForcedTypeObjectType.java @@ -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() { diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedAnnotationType.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedAnnotationType.java index 7b69cbb369..99a2409027 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedAnnotationType.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedAnnotationType.java @@ -26,10 +26,35 @@ import jakarta.xml.bind.annotation.XmlType; @XmlEnum public enum GeneratedAnnotationType { + + /** + * The Generated annotation should be detected automatically from the JDK used at code generation time. + * + */ DETECT_FROM_JDK, + + /** + * Use the javax.annotation.Generated annotation. + * + */ JAVAX_ANNOTATION_GENERATED, + + /** + * Use the javax.annotation.processing.Generated annotation. + * + */ JAVAX_ANNOTATION_PROCESSING_GENERATED, + + /** + * Use the jakarta.annotation.Generated annotation. + * + */ JAKARTA_ANNOTATION_GENERATED, + + /** + * Use the {@link org.jooq.Generated} annotation. + * + */ ORG_JOOQ_GENERATED; public String value() { diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedSerialVersionUID.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedSerialVersionUID.java index 85dbc112d0..aeeb8b14c2 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedSerialVersionUID.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedSerialVersionUID.java @@ -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() { diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedTextBlocks.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedTextBlocks.java index 661ba02825..0d921cab53 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedTextBlocks.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/GeneratedTextBlocks.java @@ -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() { diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Logging.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Logging.java index b5401d1ae6..5ff7d10d12 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Logging.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Logging.java @@ -27,11 +27,41 @@ import jakarta.xml.bind.annotation.XmlType; @XmlEnum public enum Logging { + + /** + * The TRACE log level. + * + */ TRACE, + + /** + * The DEBUG log level. + * + */ DEBUG, + + /** + * The INFO log level. + * + */ INFO, + + /** + * The WARN log level. + * + */ WARN, + + /** + * The ERROR log level. + * + */ ERROR, + + /** + * The FATAL log level. + * + */ FATAL; public String value() { diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/MatcherTransformType.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/MatcherTransformType.java index 6031a437a7..16cd93d1f7 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/MatcherTransformType.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/MatcherTransformType.java @@ -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() { diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Nullability.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Nullability.java index 3df116d0f8..eeeef7c05c 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Nullability.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/Nullability.java @@ -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() { diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/OnError.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/OnError.java index 3e4a8004bf..cb887d1645 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/OnError.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/OnError.java @@ -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() { diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/RegexFlag.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/RegexFlag.java index bb9ea8a04a..bf0efbc5e7 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/RegexFlag.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/RegexFlag.java @@ -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() { diff --git a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/VisibilityModifier.java b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/VisibilityModifier.java index 0fcd65a3e9..a3bb67c190 100644 --- a/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/VisibilityModifier.java +++ b/jOOQ-meta/src/main/java/org/jooq/meta/jaxb/VisibilityModifier.java @@ -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 public visibility (explicit public in Java, nothing in Kotlin, Scala). + * + */ DEFAULT, + + /** + * No visibility modifier is generated. + * + */ NONE, + + /** + * An explicit public visibility modifier is generated, where supported (no modifier is generated in Scala). + * + */ PUBLIC, + + /** + * An explicit internal visibility modifier is generated, where supported (or public, otherwise). + * + */ INTERNAL, + + /** + * A private visibility modifier is generated. This is useful only for {@link ForcedType}, not as a global configuration. + * + */ PRIVATE; public String value() { diff --git a/jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.20.0.xsd b/jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.20.0.xsd index bc5cb6e5b6..5ee7ec468c 100644 --- a/jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.20.0.xsd +++ b/jOOQ-meta/src/main/resources/org/jooq/meta/xsd/jooq-codegen-3.20.0.xsd @@ -40,20 +40,38 @@ - - - - - - + + TRACE log level.]]> + + + DEBUG log level.]]> + + + INFO log level.]]> + + + WARN log level.]]> + + + ERROR log level.]]> + + + FATAL log level.]]> + - - - + + + + + + + + + @@ -881,13 +899,27 @@ and follow its (undocumented!) assumptions (e.g. constructors, etc.). Use this a - - - - - - - + + + + + + + + + + + + + + + + + + + + + @@ -2514,12 +2546,24 @@ type. If provided, both "includeExpression" and "includeTypes" must match.]]> - - - - - - + + + + + + + + + + + + + + + + + + @@ -3234,68 +3278,132 @@ e.g. org.jooq.generated.schema1, org.jooq.generated.schema2]]> - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + + + + + + + + + + - - - + + + + + + + + + - - - - - + + public visibility (explicit public in Java, nothing in Kotlin, Scala).]]> + + + + + + public visibility modifier is generated, where supported (no modifier is generated in Scala).]]> + + + internal visibility modifier is generated, where supported (or public, otherwise).]]> + + + private visibility modifier is generated. This is useful only for {@link ForcedType}, not as a global configuration.]]> + - - - - - + + Generated annotation should be detected automatically from the JDK used at code generation time.]]> + + + javax.annotation.Generated annotation.]]> + + + javax.annotation.processing.Generated annotation.]]> + + + jakarta.annotation.Generated annotation.]]> + + + + - - - + + + + + + + + + - - - + + + + + + + + + diff --git a/jOOQ/src/main/java/org/jooq/conf/AutoAliasExpressions.java b/jOOQ/src/main/java/org/jooq/conf/AutoAliasExpressions.java index 8f8b118dca..1d1515d745 100644 --- a/jOOQ/src/main/java/org/jooq/conf/AutoAliasExpressions.java +++ b/jOOQ/src/main/java/org/jooq/conf/AutoAliasExpressions.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/BackslashEscaping.java b/jOOQ/src/main/java/org/jooq/conf/BackslashEscaping.java index bfb0d10c73..35f04f5d6d 100644 --- a/jOOQ/src/main/java/org/jooq/conf/BackslashEscaping.java +++ b/jOOQ/src/main/java/org/jooq/conf/BackslashEscaping.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/DiagnosticsConnection.java b/jOOQ/src/main/java/org/jooq/conf/DiagnosticsConnection.java index 2b91b9769a..bc1c422546 100644 --- a/jOOQ/src/main/java/org/jooq/conf/DiagnosticsConnection.java +++ b/jOOQ/src/main/java/org/jooq/conf/DiagnosticsConnection.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/ExecuteWithoutWhere.java b/jOOQ/src/main/java/org/jooq/conf/ExecuteWithoutWhere.java index a3327b1311..7ceb945a5c 100644 --- a/jOOQ/src/main/java/org/jooq/conf/ExecuteWithoutWhere.java +++ b/jOOQ/src/main/java/org/jooq/conf/ExecuteWithoutWhere.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/FetchIntermediateResult.java b/jOOQ/src/main/java/org/jooq/conf/FetchIntermediateResult.java index a1a9ac0bf6..7edae34bca 100644 --- a/jOOQ/src/main/java/org/jooq/conf/FetchIntermediateResult.java +++ b/jOOQ/src/main/java/org/jooq/conf/FetchIntermediateResult.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/FetchTriggerValuesAfterReturning.java b/jOOQ/src/main/java/org/jooq/conf/FetchTriggerValuesAfterReturning.java index 55c581d15e..dc2d952053 100644 --- a/jOOQ/src/main/java/org/jooq/conf/FetchTriggerValuesAfterReturning.java +++ b/jOOQ/src/main/java/org/jooq/conf/FetchTriggerValuesAfterReturning.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/InterpreterNameLookupCaseSensitivity.java b/jOOQ/src/main/java/org/jooq/conf/InterpreterNameLookupCaseSensitivity.java index 0ccb56e997..affbd68f10 100644 --- a/jOOQ/src/main/java/org/jooq/conf/InterpreterNameLookupCaseSensitivity.java +++ b/jOOQ/src/main/java/org/jooq/conf/InterpreterNameLookupCaseSensitivity.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/InvocationOrder.java b/jOOQ/src/main/java/org/jooq/conf/InvocationOrder.java index f37c2fc914..d49f746447 100644 --- a/jOOQ/src/main/java/org/jooq/conf/InvocationOrder.java +++ b/jOOQ/src/main/java/org/jooq/conf/InvocationOrder.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/NestedCollectionEmulation.java b/jOOQ/src/main/java/org/jooq/conf/NestedCollectionEmulation.java index 420983eead..c91ea2e284 100644 --- a/jOOQ/src/main/java/org/jooq/conf/NestedCollectionEmulation.java +++ b/jOOQ/src/main/java/org/jooq/conf/NestedCollectionEmulation.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/ParamCastMode.java b/jOOQ/src/main/java/org/jooq/conf/ParamCastMode.java index 77181c0a85..eb067a43a6 100644 --- a/jOOQ/src/main/java/org/jooq/conf/ParamCastMode.java +++ b/jOOQ/src/main/java/org/jooq/conf/ParamCastMode.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/ParamType.java b/jOOQ/src/main/java/org/jooq/conf/ParamType.java index 14118bbcb5..4351621a3d 100644 --- a/jOOQ/src/main/java/org/jooq/conf/ParamType.java +++ b/jOOQ/src/main/java/org/jooq/conf/ParamType.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/ParseNameCase.java b/jOOQ/src/main/java/org/jooq/conf/ParseNameCase.java index 9799fbe26c..37e0ec9670 100644 --- a/jOOQ/src/main/java/org/jooq/conf/ParseNameCase.java +++ b/jOOQ/src/main/java/org/jooq/conf/ParseNameCase.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/ParseUnknownFunctions.java b/jOOQ/src/main/java/org/jooq/conf/ParseUnknownFunctions.java index f8ceb3e43c..2f37575433 100644 --- a/jOOQ/src/main/java/org/jooq/conf/ParseUnknownFunctions.java +++ b/jOOQ/src/main/java/org/jooq/conf/ParseUnknownFunctions.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/ParseUnsupportedSyntax.java b/jOOQ/src/main/java/org/jooq/conf/ParseUnsupportedSyntax.java index 1ad1741999..d9d4a94d5c 100644 --- a/jOOQ/src/main/java/org/jooq/conf/ParseUnsupportedSyntax.java +++ b/jOOQ/src/main/java/org/jooq/conf/ParseUnsupportedSyntax.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/ParseWithMetaLookups.java b/jOOQ/src/main/java/org/jooq/conf/ParseWithMetaLookups.java index d257466a38..33dc2d4ef0 100644 --- a/jOOQ/src/main/java/org/jooq/conf/ParseWithMetaLookups.java +++ b/jOOQ/src/main/java/org/jooq/conf/ParseWithMetaLookups.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/QueryPoolable.java b/jOOQ/src/main/java/org/jooq/conf/QueryPoolable.java index fc35e75def..fe201add49 100644 --- a/jOOQ/src/main/java/org/jooq/conf/QueryPoolable.java +++ b/jOOQ/src/main/java/org/jooq/conf/QueryPoolable.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RecordDirtyTracking.java b/jOOQ/src/main/java/org/jooq/conf/RecordDirtyTracking.java index 83d5fc839b..bb61d617d7 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RecordDirtyTracking.java +++ b/jOOQ/src/main/java/org/jooq/conf/RecordDirtyTracking.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RenderDefaultNullability.java b/jOOQ/src/main/java/org/jooq/conf/RenderDefaultNullability.java index 0b6204f222..a83145d91c 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RenderDefaultNullability.java +++ b/jOOQ/src/main/java/org/jooq/conf/RenderDefaultNullability.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RenderImplicitJoinType.java b/jOOQ/src/main/java/org/jooq/conf/RenderImplicitJoinType.java index d45abe7f1d..a6a584d07b 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RenderImplicitJoinType.java +++ b/jOOQ/src/main/java/org/jooq/conf/RenderImplicitJoinType.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RenderImplicitWindowRange.java b/jOOQ/src/main/java/org/jooq/conf/RenderImplicitWindowRange.java index afad5b2845..fbf69e2b0f 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RenderImplicitWindowRange.java +++ b/jOOQ/src/main/java/org/jooq/conf/RenderImplicitWindowRange.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RenderKeywordCase.java b/jOOQ/src/main/java/org/jooq/conf/RenderKeywordCase.java index d140bfaf6b..47f6c15666 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RenderKeywordCase.java +++ b/jOOQ/src/main/java/org/jooq/conf/RenderKeywordCase.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RenderKeywordStyle.java b/jOOQ/src/main/java/org/jooq/conf/RenderKeywordStyle.java index 84dc7c817c..049b9ab8e8 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RenderKeywordStyle.java +++ b/jOOQ/src/main/java/org/jooq/conf/RenderKeywordStyle.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RenderNameCase.java b/jOOQ/src/main/java/org/jooq/conf/RenderNameCase.java index cb3daec6c9..e658e701e3 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RenderNameCase.java +++ b/jOOQ/src/main/java/org/jooq/conf/RenderNameCase.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RenderNameStyle.java b/jOOQ/src/main/java/org/jooq/conf/RenderNameStyle.java index 8700d1e58e..26e5507eec 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RenderNameStyle.java +++ b/jOOQ/src/main/java/org/jooq/conf/RenderNameStyle.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RenderOptionalKeyword.java b/jOOQ/src/main/java/org/jooq/conf/RenderOptionalKeyword.java index 7d0606172a..38b6484376 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RenderOptionalKeyword.java +++ b/jOOQ/src/main/java/org/jooq/conf/RenderOptionalKeyword.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/RenderQuotedNames.java b/jOOQ/src/main/java/org/jooq/conf/RenderQuotedNames.java index becd4cdf9b..299fd20666 100644 --- a/jOOQ/src/main/java/org/jooq/conf/RenderQuotedNames.java +++ b/jOOQ/src/main/java/org/jooq/conf/RenderQuotedNames.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/StatementType.java b/jOOQ/src/main/java/org/jooq/conf/StatementType.java index 7ec240ce85..38c3112401 100644 --- a/jOOQ/src/main/java/org/jooq/conf/StatementType.java +++ b/jOOQ/src/main/java/org/jooq/conf/StatementType.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/ThrowExceptions.java b/jOOQ/src/main/java/org/jooq/conf/ThrowExceptions.java index 4c064ac51f..e0cb0c2b23 100644 --- a/jOOQ/src/main/java/org/jooq/conf/ThrowExceptions.java +++ b/jOOQ/src/main/java/org/jooq/conf/ThrowExceptions.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/TransformUnneededArithmeticExpressions.java b/jOOQ/src/main/java/org/jooq/conf/TransformUnneededArithmeticExpressions.java index 9ef31f798e..ab15bfa238 100644 --- a/jOOQ/src/main/java/org/jooq/conf/TransformUnneededArithmeticExpressions.java +++ b/jOOQ/src/main/java/org/jooq/conf/TransformUnneededArithmeticExpressions.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/Transformation.java b/jOOQ/src/main/java/org/jooq/conf/Transformation.java index b483b2c559..914ae85ac4 100644 --- a/jOOQ/src/main/java/org/jooq/conf/Transformation.java +++ b/jOOQ/src/main/java/org/jooq/conf/Transformation.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/UpdateUnchangedRecords.java b/jOOQ/src/main/java/org/jooq/conf/UpdateUnchangedRecords.java index a09f4256fd..ccc9981027 100644 --- a/jOOQ/src/main/java/org/jooq/conf/UpdateUnchangedRecords.java +++ b/jOOQ/src/main/java/org/jooq/conf/UpdateUnchangedRecords.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/Warning.java b/jOOQ/src/main/java/org/jooq/conf/Warning.java index 55bffde2a7..463f1cb888 100644 --- a/jOOQ/src/main/java/org/jooq/conf/Warning.java +++ b/jOOQ/src/main/java/org/jooq/conf/Warning.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/conf/WriteIfReadonly.java b/jOOQ/src/main/java/org/jooq/conf/WriteIfReadonly.java index a81f7b5c82..3e9ef586bf 100644 --- a/jOOQ/src/main/java/org/jooq/conf/WriteIfReadonly.java +++ b/jOOQ/src/main/java/org/jooq/conf/WriteIfReadonly.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/migrations/xml/jaxb/ChangeType.java b/jOOQ/src/main/java/org/jooq/migrations/xml/jaxb/ChangeType.java index 790985e6e3..8b60ab5598 100644 --- a/jOOQ/src/main/java/org/jooq/migrations/xml/jaxb/ChangeType.java +++ b/jOOQ/src/main/java/org/jooq/migrations/xml/jaxb/ChangeType.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/ForeignKeyRule.java b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/ForeignKeyRule.java index 81e7862911..4b1c30ab63 100644 --- a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/ForeignKeyRule.java +++ b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/ForeignKeyRule.java @@ -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; diff --git a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/ParameterMode.java b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/ParameterMode.java index 51c6a03622..37b6264f61 100644 --- a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/ParameterMode.java +++ b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/ParameterMode.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/RoutineType.java b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/RoutineType.java index 599152f3a4..2621650af1 100644 --- a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/RoutineType.java +++ b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/RoutineType.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableConstraintType.java b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableConstraintType.java index 6cd558b3e7..c6f43a543b 100644 --- a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableConstraintType.java +++ b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableConstraintType.java @@ -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; diff --git a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableType.java b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableType.java index 87a29fc085..4053e17f44 100644 --- a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableType.java +++ b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TableType.java @@ -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; diff --git a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionOrientation.java b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionOrientation.java index 63d5d54f9c..2d9d168626 100644 --- a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionOrientation.java +++ b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionOrientation.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionTiming.java b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionTiming.java index 9e5f76b687..7cf47551d5 100644 --- a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionTiming.java +++ b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerActionTiming.java @@ -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() { diff --git a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerEventManipulation.java b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerEventManipulation.java index fd16bc6bd2..b3e864fef9 100644 --- a/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerEventManipulation.java +++ b/jOOQ/src/main/java/org/jooq/util/xml/jaxb/TriggerEventManipulation.java @@ -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() { diff --git a/jOOQ/src/main/resources/org/jooq/xsd/jooq-meta-3.20.0.xsd b/jOOQ/src/main/resources/org/jooq/xsd/jooq-meta-3.20.0.xsd index c8e3d48fdf..c1af73c3aa 100644 --- a/jOOQ/src/main/resources/org/jooq/xsd/jooq-meta-3.20.0.xsd +++ b/jOOQ/src/main/resources/org/jooq/xsd/jooq-meta-3.20.0.xsd @@ -1,8 +1,12 @@ + elementFormDefault="qualified" + jxb:extensionBindingPrefixes="annox" + jxb:version="2.1"> @@ -424,24 +428,40 @@ - - - + + + + + + + + + - - + + + + + + - - - + + + + + + + + + @@ -456,44 +476,80 @@ - - - + + + + + + + + + - - + + + + + + - - - - + + + + + + + + + + + + - - - - + + + + + + + + + + + + - - - - - + + + + + + + + + + + + + + + diff --git a/jOOQ/src/main/resources/org/jooq/xsd/jooq-migrations-3.20.0.xsd b/jOOQ/src/main/resources/org/jooq/xsd/jooq-migrations-3.20.0.xsd index e13d7c38d2..9ccc637c63 100644 --- a/jOOQ/src/main/resources/org/jooq/xsd/jooq-migrations-3.20.0.xsd +++ b/jOOQ/src/main/resources/org/jooq/xsd/jooq-migrations-3.20.0.xsd @@ -1,8 +1,12 @@ + elementFormDefault="qualified" + jxb:extensionBindingPrefixes="annox" + jxb:version="2.1"> @@ -72,11 +76,21 @@ - - - - - + + + + + + + + + + + + + + + diff --git a/jOOQ/src/main/resources/org/jooq/xsd/jooq-runtime-3.20.0.xsd b/jOOQ/src/main/resources/org/jooq/xsd/jooq-runtime-3.20.0.xsd index 0718e6bc57..d7fbb6eb60 100644 --- a/jOOQ/src/main/resources/org/jooq/xsd/jooq-runtime-3.20.0.xsd +++ b/jOOQ/src/main/resources/org/jooq/xsd/jooq-runtime-3.20.0.xsd @@ -1951,62 +1951,71 @@ Either <input/> or <inputExpression/> must be provided]]> + + + - - + + + - - + + + - - - - - + + + - + + + + + + - - - - - + the query parser do its job. The exact behaviour of this mode is undefined and subject to change.]]> + - - + + + + + + - - - - - + + + + + + - - - - - + + + @@ -2017,95 +2026,108 @@ Either <input/> or <inputExpression/> must be provided]]> - - - + SQL Server: [INFORMATION_SCHEMA].[TABLES]]]> + - - + SQL Server: INFORMATION_SCHEMA.TABLES]]> + - - + SQL Server: information_schema.tables]]> + - - + SQL Server: INFORMATION_SCHEMA.TABLES]]> + - - - + SQL Server: [INFORMATION_SCHEMA].[TABLES]]]> + - - + + + - - + + + - - + + + + + + - - + + + - - + + + - - + + + - - - - - + + + + + + - - + + + - - + + + - - - - - + + + @@ -2116,22 +2138,25 @@ Either <input/> or <inputExpression/> must be provided]]> + + + - - + + + - - + + + - - - - - + + + @@ -2155,15 +2180,17 @@ Either <input/> or <inputExpression/> must be provided]]> - - - + + + - - + + + - - + + + @@ -2177,367 +2204,427 @@ Either <input/> or <inputExpression/> must be provided]]> --> - - + + + - - + + + - - + + + + + + - - + + + - - - - - + + + + + + - - + + + - - + + + - - + + + - - - - - + + + + + + - - + + + - - + + + - - + + + - - - - - + + + - - - + + + - - + + + - - + + + - - + + + - - + + + - - - + + + - - + + + - - + + + - - - + + + - - + + + - - + + + - - - + + + - - + + + - - + + + - - + + + - - + + + - - - + + + - - + + + - - + + + - - + + + - - + + + - - + + + - - + + + - - + + + - - + + + - - + + + + + + - - + + + - - - - - + + + + + + - - - - - + + + + + + - - - - - + + + + + + - - + + + - - - - - + + + + + + - - + + + - - + + + - - - - - + + + - - - + + + - - + + + - - - + + + - - + + + - - + + + - - - + + + - - + + + - - + + + + + + - - + + + - - - - - + + + + + + - - - - - + + + - - + + + - - + + + - - + + + - - - + + + - - + + + - - + + + - - - + + + - - + + + - - + + + - - - + + + - - + + + - - + + + \ No newline at end of file